Commit | Line | Data |
---|---|---|
ed9f1fb2 JG |
1 | /* |
2 | * schedule_api.c | |
3 | * | |
4 | * Unit tests for the session rotation schedule API | |
5 | * | |
6 | * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
7 | * | |
9d16b343 | 8 | * SPDX-License-Identifier: MIT |
ed9f1fb2 | 9 | * |
ed9f1fb2 JG |
10 | */ |
11 | ||
12 | #include <stddef.h> | |
13 | #include <stdbool.h> | |
14 | #include <tap/tap.h> | |
15 | ||
16 | #include <lttng/lttng.h> | |
17 | ||
18 | #define NUM_TESTS 26 | |
19 | ||
20 | #define SIZE_THRESHOLD_BYTES 1024 | |
21 | #define PERIODIC_TIME_US 1000000 | |
22 | ||
23 | const char *session_name; | |
24 | ||
f12eb9c1 | 25 | static |
ed9f1fb2 JG |
26 | bool schedules_equal(const struct lttng_rotation_schedule *a, |
27 | const struct lttng_rotation_schedule *b) | |
28 | { | |
29 | bool equal = false; | |
30 | enum lttng_rotation_schedule_type a_type, b_type; | |
31 | uint64_t a_value, b_value; | |
32 | enum lttng_rotation_status status; | |
33 | ||
34 | a_type = lttng_rotation_schedule_get_type(a); | |
35 | b_type = lttng_rotation_schedule_get_type(b); | |
36 | if (a_type != b_type) { | |
37 | diag("Schedules are not of the same type (%i != %i)", | |
38 | a_type, b_type); | |
39 | goto end; | |
40 | } | |
41 | ||
42 | switch (a_type) { | |
43 | case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: | |
44 | { | |
45 | status = lttng_rotation_schedule_size_threshold_get_threshold(a, | |
46 | &a_value); | |
47 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
48 | diag("Failed to retrieve size threshold of schedule 'a'"); | |
49 | goto end; | |
50 | } | |
51 | status = lttng_rotation_schedule_size_threshold_get_threshold(b, | |
52 | &b_value); | |
53 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
54 | diag("Failed to retrieve size threshold of schedule 'b'"); | |
55 | goto end; | |
56 | } | |
57 | break; | |
58 | } | |
59 | case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: | |
60 | { | |
61 | status = lttng_rotation_schedule_periodic_get_period(a, | |
62 | &a_value); | |
63 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
64 | diag("Failed to retrieve period of schedule 'a'"); | |
65 | goto end; | |
66 | } | |
67 | status = lttng_rotation_schedule_periodic_get_period(b, | |
68 | &b_value); | |
69 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
70 | diag("Failed to retrieve period of schedule 'b'"); | |
71 | goto end; | |
72 | } | |
73 | break; | |
74 | } | |
75 | default: | |
76 | diag("Unexpected schedule type: %i", a_type); | |
77 | goto end; | |
78 | } | |
79 | ||
80 | equal = a_value == b_value; | |
81 | if (!equal) { | |
82 | diag("Schedules have different values"); | |
83 | } | |
84 | end: | |
85 | return equal; | |
86 | } | |
87 | ||
f12eb9c1 | 88 | static |
ed9f1fb2 JG |
89 | void test_add_null_session(void) |
90 | { | |
91 | enum lttng_rotation_status status; | |
92 | struct lttng_rotation_schedule *size_schedule = NULL; | |
93 | ||
94 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
95 | ||
96 | status = lttng_session_add_rotation_schedule(NULL, size_schedule); | |
97 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
98 | "NULL session name rejected by lttng_session_add_rotation_schedule()"); | |
4edd268b | 99 | lttng_rotation_schedule_destroy(size_schedule); |
ed9f1fb2 JG |
100 | } |
101 | ||
f12eb9c1 | 102 | static |
ed9f1fb2 JG |
103 | void test_add_null_schedule(void) |
104 | { | |
105 | enum lttng_rotation_status status; | |
106 | ||
107 | status = lttng_session_add_rotation_schedule(session_name, NULL); | |
108 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
109 | "NULL schedule rejected by lttng_session_add_rotation_schedule()"); | |
110 | } | |
111 | ||
f12eb9c1 | 112 | static |
ed9f1fb2 JG |
113 | void test_add_uninitialized_schedule(void) |
114 | { | |
115 | enum lttng_rotation_status status; | |
116 | struct lttng_rotation_schedule *size_schedule = NULL, | |
117 | *periodic_schedule = NULL; | |
118 | ||
119 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
120 | ok(size_schedule, "Created a size threshold session rotation schedule"); | |
121 | ||
122 | status = lttng_session_add_rotation_schedule(session_name, | |
123 | size_schedule); | |
124 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
125 | "Uninitialized size schedule rejected by lttng_session_add_rotation_schedule()"); | |
126 | ||
127 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
128 | ok(periodic_schedule, "Created a periodic session rotation schedule"); | |
129 | ||
130 | status = lttng_session_add_rotation_schedule(session_name, | |
131 | periodic_schedule); | |
132 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
133 | "Uninitialized periodic schedule rejected by lttng_session_add_rotation_schedule()"); | |
134 | ||
135 | lttng_rotation_schedule_destroy(size_schedule); | |
136 | lttng_rotation_schedule_destroy(periodic_schedule); | |
137 | } | |
138 | ||
f12eb9c1 | 139 | static |
ed9f1fb2 JG |
140 | void test_remove_null_session(void) |
141 | { | |
142 | enum lttng_rotation_status status; | |
143 | struct lttng_rotation_schedule *size_schedule = NULL; | |
144 | ||
145 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
146 | ||
147 | status = lttng_session_remove_rotation_schedule(NULL, size_schedule); | |
148 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
149 | "NULL session name rejected by lttng_session_remove_rotation_schedule()"); | |
4edd268b | 150 | lttng_rotation_schedule_destroy(size_schedule); |
ed9f1fb2 JG |
151 | } |
152 | ||
f12eb9c1 | 153 | static |
ed9f1fb2 JG |
154 | void test_remove_null_schedule(void) |
155 | { | |
156 | enum lttng_rotation_status status; | |
157 | ||
158 | status = lttng_session_remove_rotation_schedule(session_name, NULL); | |
159 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
160 | "NULL schedule rejected by lttng_session_remove_rotation_schedule()"); | |
161 | } | |
162 | ||
f12eb9c1 | 163 | static |
ed9f1fb2 JG |
164 | void test_remove_uninitialized_schedule(void) |
165 | { | |
166 | enum lttng_rotation_status status; | |
167 | struct lttng_rotation_schedule *size_schedule = NULL, | |
168 | *periodic_schedule = NULL; | |
169 | ||
170 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
171 | status = lttng_session_remove_rotation_schedule(session_name, | |
172 | size_schedule); | |
173 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
174 | "Uninitialized size schedule rejected by lttng_session_remove_rotation_schedule()"); | |
175 | ||
176 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
177 | status = lttng_session_remove_rotation_schedule(session_name, | |
178 | periodic_schedule); | |
179 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
180 | "Uninitialized periodic schedule rejected by lttng_session_remove_rotation_schedule()"); | |
181 | ||
182 | lttng_rotation_schedule_destroy(size_schedule); | |
183 | lttng_rotation_schedule_destroy(periodic_schedule); | |
184 | } | |
185 | ||
f12eb9c1 | 186 | static |
ed9f1fb2 JG |
187 | void test_uninitialized_schedule_get(void) |
188 | { | |
189 | uint64_t value; | |
190 | enum lttng_rotation_status status; | |
191 | struct lttng_rotation_schedule *size_schedule = NULL, | |
192 | *periodic_schedule = NULL; | |
193 | ||
194 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
195 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
196 | ||
197 | status = lttng_rotation_schedule_size_threshold_get_threshold( | |
198 | size_schedule, &value); | |
199 | ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE, | |
200 | "Getter on size threshold rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default"); | |
201 | status = lttng_rotation_schedule_periodic_get_period(periodic_schedule, | |
202 | &value); | |
203 | ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE, | |
204 | "Getter on periodic rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default"); | |
205 | ||
206 | lttng_rotation_schedule_destroy(size_schedule); | |
207 | lttng_rotation_schedule_destroy(periodic_schedule); | |
208 | ||
209 | } | |
210 | ||
f12eb9c1 | 211 | static |
ed9f1fb2 JG |
212 | void test_add_list_remove_schedule( |
213 | const struct lttng_rotation_schedule *original_schedule) | |
214 | { | |
215 | int ret; | |
216 | unsigned int schedules_count = 0; | |
217 | enum lttng_rotation_status status; | |
218 | const struct lttng_rotation_schedule *list_schedule; | |
219 | struct lttng_rotation_schedules *list_schedules; | |
220 | ||
221 | status = lttng_session_add_rotation_schedule(session_name, | |
222 | original_schedule); | |
223 | ok(status == LTTNG_ROTATION_STATUS_OK, | |
224 | "Add a rotation schedule to session \'%s\'", | |
225 | session_name); | |
226 | ||
227 | ret = lttng_session_list_rotation_schedules(session_name, | |
228 | &list_schedules); | |
229 | ok(ret == LTTNG_OK && list_schedules, | |
230 | "List rotation schedules of session \'%s\'", | |
231 | session_name); | |
232 | ||
233 | status = lttng_rotation_schedules_get_count(list_schedules, | |
234 | &schedules_count); | |
235 | ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 1, | |
236 | "Listing returned 1 rotation schedule"); | |
237 | ||
238 | list_schedule = lttng_rotation_schedules_get_at_index(list_schedules, | |
239 | 0); | |
240 | ok(list_schedule, | |
241 | "Obtain the first schedule of a schedules list"); | |
242 | ||
243 | ok(schedules_equal(original_schedule, list_schedule), | |
244 | "Schedule returned by the listing is equal to the reference schedule that was added"); | |
245 | ||
246 | status = lttng_session_remove_rotation_schedule(session_name, | |
247 | list_schedule); | |
248 | ok(status == LTTNG_ROTATION_STATUS_OK, | |
249 | "Remove rotation schedule returned by the schedules listing"); | |
250 | lttng_rotation_schedules_destroy(list_schedules); | |
251 | ||
252 | (void) lttng_session_list_rotation_schedules(session_name, | |
253 | &list_schedules); | |
254 | status = lttng_rotation_schedules_get_count(list_schedules, | |
255 | &schedules_count); | |
256 | ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 0, | |
257 | "Listing returned 0 rotation schedules after removal"); | |
258 | ||
259 | } | |
260 | ||
f12eb9c1 | 261 | static |
ed9f1fb2 JG |
262 | void test_add_list_remove_size_schedule(void) |
263 | { | |
264 | struct lttng_rotation_schedule *size_schedule; | |
265 | ||
266 | diag("Add, list, and remove a size threshold rotation schedule"); | |
267 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
268 | (void) lttng_rotation_schedule_size_threshold_set_threshold( | |
269 | size_schedule, SIZE_THRESHOLD_BYTES); | |
270 | test_add_list_remove_schedule(size_schedule); | |
271 | lttng_rotation_schedule_destroy(size_schedule); | |
272 | } | |
273 | ||
f12eb9c1 | 274 | static |
ed9f1fb2 JG |
275 | void test_add_list_remove_periodic_schedule(void) |
276 | { | |
277 | struct lttng_rotation_schedule *periodic_schedule; | |
278 | ||
279 | diag("Add, list, and remove a periodic rotation schedule"); | |
280 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
281 | (void) lttng_rotation_schedule_periodic_set_period( | |
282 | periodic_schedule, PERIODIC_TIME_US); | |
283 | test_add_list_remove_schedule(periodic_schedule); | |
284 | lttng_rotation_schedule_destroy(periodic_schedule); | |
285 | } | |
286 | ||
287 | int main(int argc, char **argv) | |
288 | { | |
289 | plan_tests(NUM_TESTS); | |
290 | ||
291 | if (argc < 2) { | |
292 | diag("Usage: schedule_api SESSION_NAME"); | |
293 | goto end; | |
294 | } | |
295 | ||
296 | session_name = argv[1]; | |
297 | ||
298 | diag("Argument validation"); | |
299 | test_add_null_session(); | |
300 | test_add_null_schedule(); | |
301 | test_add_uninitialized_schedule(); | |
302 | test_remove_null_session(); | |
303 | test_remove_null_schedule(); | |
304 | test_remove_uninitialized_schedule(); | |
305 | test_uninitialized_schedule_get(); | |
306 | ||
307 | test_add_list_remove_size_schedule(); | |
308 | test_add_list_remove_periodic_schedule(); | |
309 | end: | |
310 | return exit_status(); | |
311 | } |