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 | * | |
8 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
9 | * of this software and associated documentation files (the "Software"), to deal | |
10 | * in the Software without restriction, including without limitation the rights | |
11 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
12 | * copies of the Software, and to permit persons to whom the Software is | |
13 | * furnished to do so, subject to the following conditions: | |
14 | * | |
15 | * The above copyright notice and this permission notice shall be included in | |
16 | * all copies or substantial portions of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
21 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
23 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
24 | * SOFTWARE. | |
25 | */ | |
26 | ||
27 | #include <stddef.h> | |
28 | #include <stdbool.h> | |
29 | #include <tap/tap.h> | |
30 | ||
31 | #include <lttng/lttng.h> | |
32 | ||
33 | #define NUM_TESTS 26 | |
34 | ||
35 | #define SIZE_THRESHOLD_BYTES 1024 | |
36 | #define PERIODIC_TIME_US 1000000 | |
37 | ||
38 | const char *session_name; | |
39 | ||
40 | bool schedules_equal(const struct lttng_rotation_schedule *a, | |
41 | const struct lttng_rotation_schedule *b) | |
42 | { | |
43 | bool equal = false; | |
44 | enum lttng_rotation_schedule_type a_type, b_type; | |
45 | uint64_t a_value, b_value; | |
46 | enum lttng_rotation_status status; | |
47 | ||
48 | a_type = lttng_rotation_schedule_get_type(a); | |
49 | b_type = lttng_rotation_schedule_get_type(b); | |
50 | if (a_type != b_type) { | |
51 | diag("Schedules are not of the same type (%i != %i)", | |
52 | a_type, b_type); | |
53 | goto end; | |
54 | } | |
55 | ||
56 | switch (a_type) { | |
57 | case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD: | |
58 | { | |
59 | status = lttng_rotation_schedule_size_threshold_get_threshold(a, | |
60 | &a_value); | |
61 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
62 | diag("Failed to retrieve size threshold of schedule 'a'"); | |
63 | goto end; | |
64 | } | |
65 | status = lttng_rotation_schedule_size_threshold_get_threshold(b, | |
66 | &b_value); | |
67 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
68 | diag("Failed to retrieve size threshold of schedule 'b'"); | |
69 | goto end; | |
70 | } | |
71 | break; | |
72 | } | |
73 | case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC: | |
74 | { | |
75 | status = lttng_rotation_schedule_periodic_get_period(a, | |
76 | &a_value); | |
77 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
78 | diag("Failed to retrieve period of schedule 'a'"); | |
79 | goto end; | |
80 | } | |
81 | status = lttng_rotation_schedule_periodic_get_period(b, | |
82 | &b_value); | |
83 | if (status != LTTNG_ROTATION_STATUS_OK) { | |
84 | diag("Failed to retrieve period of schedule 'b'"); | |
85 | goto end; | |
86 | } | |
87 | break; | |
88 | } | |
89 | default: | |
90 | diag("Unexpected schedule type: %i", a_type); | |
91 | goto end; | |
92 | } | |
93 | ||
94 | equal = a_value == b_value; | |
95 | if (!equal) { | |
96 | diag("Schedules have different values"); | |
97 | } | |
98 | end: | |
99 | return equal; | |
100 | } | |
101 | ||
102 | void test_add_null_session(void) | |
103 | { | |
104 | enum lttng_rotation_status status; | |
105 | struct lttng_rotation_schedule *size_schedule = NULL; | |
106 | ||
107 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
108 | ||
109 | status = lttng_session_add_rotation_schedule(NULL, size_schedule); | |
110 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
111 | "NULL session name rejected by lttng_session_add_rotation_schedule()"); | |
4edd268b | 112 | lttng_rotation_schedule_destroy(size_schedule); |
ed9f1fb2 JG |
113 | } |
114 | ||
115 | void test_add_null_schedule(void) | |
116 | { | |
117 | enum lttng_rotation_status status; | |
118 | ||
119 | status = lttng_session_add_rotation_schedule(session_name, NULL); | |
120 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
121 | "NULL schedule rejected by lttng_session_add_rotation_schedule()"); | |
122 | } | |
123 | ||
124 | void test_add_uninitialized_schedule(void) | |
125 | { | |
126 | enum lttng_rotation_status status; | |
127 | struct lttng_rotation_schedule *size_schedule = NULL, | |
128 | *periodic_schedule = NULL; | |
129 | ||
130 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
131 | ok(size_schedule, "Created a size threshold session rotation schedule"); | |
132 | ||
133 | status = lttng_session_add_rotation_schedule(session_name, | |
134 | size_schedule); | |
135 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
136 | "Uninitialized size schedule rejected by lttng_session_add_rotation_schedule()"); | |
137 | ||
138 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
139 | ok(periodic_schedule, "Created a periodic session rotation schedule"); | |
140 | ||
141 | status = lttng_session_add_rotation_schedule(session_name, | |
142 | periodic_schedule); | |
143 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
144 | "Uninitialized periodic schedule rejected by lttng_session_add_rotation_schedule()"); | |
145 | ||
146 | lttng_rotation_schedule_destroy(size_schedule); | |
147 | lttng_rotation_schedule_destroy(periodic_schedule); | |
148 | } | |
149 | ||
150 | void test_remove_null_session(void) | |
151 | { | |
152 | enum lttng_rotation_status status; | |
153 | struct lttng_rotation_schedule *size_schedule = NULL; | |
154 | ||
155 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
156 | ||
157 | status = lttng_session_remove_rotation_schedule(NULL, size_schedule); | |
158 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
159 | "NULL session name rejected by lttng_session_remove_rotation_schedule()"); | |
4edd268b | 160 | lttng_rotation_schedule_destroy(size_schedule); |
ed9f1fb2 JG |
161 | } |
162 | ||
163 | void test_remove_null_schedule(void) | |
164 | { | |
165 | enum lttng_rotation_status status; | |
166 | ||
167 | status = lttng_session_remove_rotation_schedule(session_name, NULL); | |
168 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
169 | "NULL schedule rejected by lttng_session_remove_rotation_schedule()"); | |
170 | } | |
171 | ||
172 | void test_remove_uninitialized_schedule(void) | |
173 | { | |
174 | enum lttng_rotation_status status; | |
175 | struct lttng_rotation_schedule *size_schedule = NULL, | |
176 | *periodic_schedule = NULL; | |
177 | ||
178 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
179 | status = lttng_session_remove_rotation_schedule(session_name, | |
180 | size_schedule); | |
181 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
182 | "Uninitialized size schedule rejected by lttng_session_remove_rotation_schedule()"); | |
183 | ||
184 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
185 | status = lttng_session_remove_rotation_schedule(session_name, | |
186 | periodic_schedule); | |
187 | ok(status == LTTNG_ROTATION_STATUS_INVALID, | |
188 | "Uninitialized periodic schedule rejected by lttng_session_remove_rotation_schedule()"); | |
189 | ||
190 | lttng_rotation_schedule_destroy(size_schedule); | |
191 | lttng_rotation_schedule_destroy(periodic_schedule); | |
192 | } | |
193 | ||
194 | void test_uninitialized_schedule_get(void) | |
195 | { | |
196 | uint64_t value; | |
197 | enum lttng_rotation_status status; | |
198 | struct lttng_rotation_schedule *size_schedule = NULL, | |
199 | *periodic_schedule = NULL; | |
200 | ||
201 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
202 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
203 | ||
204 | status = lttng_rotation_schedule_size_threshold_get_threshold( | |
205 | size_schedule, &value); | |
206 | ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE, | |
207 | "Getter on size threshold rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default"); | |
208 | status = lttng_rotation_schedule_periodic_get_period(periodic_schedule, | |
209 | &value); | |
210 | ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE, | |
211 | "Getter on periodic rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default"); | |
212 | ||
213 | lttng_rotation_schedule_destroy(size_schedule); | |
214 | lttng_rotation_schedule_destroy(periodic_schedule); | |
215 | ||
216 | } | |
217 | ||
218 | void test_add_list_remove_schedule( | |
219 | const struct lttng_rotation_schedule *original_schedule) | |
220 | { | |
221 | int ret; | |
222 | unsigned int schedules_count = 0; | |
223 | enum lttng_rotation_status status; | |
224 | const struct lttng_rotation_schedule *list_schedule; | |
225 | struct lttng_rotation_schedules *list_schedules; | |
226 | ||
227 | status = lttng_session_add_rotation_schedule(session_name, | |
228 | original_schedule); | |
229 | ok(status == LTTNG_ROTATION_STATUS_OK, | |
230 | "Add a rotation schedule to session \'%s\'", | |
231 | session_name); | |
232 | ||
233 | ret = lttng_session_list_rotation_schedules(session_name, | |
234 | &list_schedules); | |
235 | ok(ret == LTTNG_OK && list_schedules, | |
236 | "List rotation schedules of session \'%s\'", | |
237 | session_name); | |
238 | ||
239 | status = lttng_rotation_schedules_get_count(list_schedules, | |
240 | &schedules_count); | |
241 | ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 1, | |
242 | "Listing returned 1 rotation schedule"); | |
243 | ||
244 | list_schedule = lttng_rotation_schedules_get_at_index(list_schedules, | |
245 | 0); | |
246 | ok(list_schedule, | |
247 | "Obtain the first schedule of a schedules list"); | |
248 | ||
249 | ok(schedules_equal(original_schedule, list_schedule), | |
250 | "Schedule returned by the listing is equal to the reference schedule that was added"); | |
251 | ||
252 | status = lttng_session_remove_rotation_schedule(session_name, | |
253 | list_schedule); | |
254 | ok(status == LTTNG_ROTATION_STATUS_OK, | |
255 | "Remove rotation schedule returned by the schedules listing"); | |
256 | lttng_rotation_schedules_destroy(list_schedules); | |
257 | ||
258 | (void) lttng_session_list_rotation_schedules(session_name, | |
259 | &list_schedules); | |
260 | status = lttng_rotation_schedules_get_count(list_schedules, | |
261 | &schedules_count); | |
262 | ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 0, | |
263 | "Listing returned 0 rotation schedules after removal"); | |
264 | ||
265 | } | |
266 | ||
267 | void test_add_list_remove_size_schedule(void) | |
268 | { | |
269 | struct lttng_rotation_schedule *size_schedule; | |
270 | ||
271 | diag("Add, list, and remove a size threshold rotation schedule"); | |
272 | size_schedule = lttng_rotation_schedule_size_threshold_create(); | |
273 | (void) lttng_rotation_schedule_size_threshold_set_threshold( | |
274 | size_schedule, SIZE_THRESHOLD_BYTES); | |
275 | test_add_list_remove_schedule(size_schedule); | |
276 | lttng_rotation_schedule_destroy(size_schedule); | |
277 | } | |
278 | ||
279 | void test_add_list_remove_periodic_schedule(void) | |
280 | { | |
281 | struct lttng_rotation_schedule *periodic_schedule; | |
282 | ||
283 | diag("Add, list, and remove a periodic rotation schedule"); | |
284 | periodic_schedule = lttng_rotation_schedule_periodic_create(); | |
285 | (void) lttng_rotation_schedule_periodic_set_period( | |
286 | periodic_schedule, PERIODIC_TIME_US); | |
287 | test_add_list_remove_schedule(periodic_schedule); | |
288 | lttng_rotation_schedule_destroy(periodic_schedule); | |
289 | } | |
290 | ||
291 | int main(int argc, char **argv) | |
292 | { | |
293 | plan_tests(NUM_TESTS); | |
294 | ||
295 | if (argc < 2) { | |
296 | diag("Usage: schedule_api SESSION_NAME"); | |
297 | goto end; | |
298 | } | |
299 | ||
300 | session_name = argv[1]; | |
301 | ||
302 | diag("Argument validation"); | |
303 | test_add_null_session(); | |
304 | test_add_null_schedule(); | |
305 | test_add_uninitialized_schedule(); | |
306 | test_remove_null_session(); | |
307 | test_remove_null_schedule(); | |
308 | test_remove_uninitialized_schedule(); | |
309 | test_uninitialized_schedule_get(); | |
310 | ||
311 | test_add_list_remove_size_schedule(); | |
312 | test_add_list_remove_periodic_schedule(); | |
313 | end: | |
314 | return exit_status(); | |
315 | } |