Commit | Line | Data |
---|---|---|
2d0e6286 JG |
1 | /* |
2 | * trigger_name.c | |
3 | * | |
4 | * Tests suite for anonymous, named, and automatic name triggers. | |
5 | * | |
6 | * Copyright (C) 2021 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
7 | * | |
8 | * SPDX-License-Identifier: MIT | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <stdio.h> | |
13 | #include <unistd.h> | |
2d0e6286 JG |
14 | #include <tap/tap.h> |
15 | #include <stdint.h> | |
16 | #include <string.h> | |
17 | #include <lttng/lttng.h> | |
18 | #include <common/macros.h> | |
19 | ||
20 | #define TEST_COUNT 70 | |
21 | ||
22 | enum unregistration_trigger_instance { | |
23 | UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION, | |
24 | UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING, | |
25 | }; | |
26 | ||
27 | typedef void (*test_function)(enum unregistration_trigger_instance); | |
28 | ||
29 | static | |
30 | const char *get_trigger_name(const struct lttng_trigger *trigger) | |
31 | { | |
32 | const char *trigger_name; | |
33 | enum lttng_trigger_status trigger_status; | |
34 | ||
35 | trigger_status = lttng_trigger_get_name(trigger, &trigger_name); | |
36 | switch (trigger_status) { | |
37 | case LTTNG_TRIGGER_STATUS_OK: | |
38 | break; | |
39 | case LTTNG_TRIGGER_STATUS_UNSET: | |
40 | trigger_name = "(anonymous)"; | |
41 | break; | |
42 | default: | |
43 | trigger_name = "(failed to get name)"; | |
44 | break; | |
45 | } | |
46 | ||
47 | return trigger_name; | |
48 | } | |
49 | ||
50 | static | |
51 | const char *unregistration_trigger_instance_name( | |
52 | enum unregistration_trigger_instance unregistration_trigger) | |
53 | { | |
54 | const char *name; | |
55 | ||
56 | switch (unregistration_trigger) { | |
57 | case UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING: | |
58 | name = "from listing"; | |
59 | break; | |
60 | case UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION: | |
61 | name = "used for registration"; | |
62 | break; | |
63 | default: | |
64 | abort(); | |
65 | } | |
66 | ||
67 | return name; | |
68 | } | |
69 | ||
70 | /* | |
71 | * Returns a negative error code on error, else the number of unregistered | |
72 | * triggers. | |
73 | */ | |
74 | static | |
75 | int unregister_all_triggers(void) | |
76 | { | |
77 | int ret; | |
78 | enum lttng_error_code ret_code; | |
79 | enum lttng_trigger_status trigger_status; | |
80 | struct lttng_triggers *triggers = NULL; | |
81 | unsigned int trigger_count, i, unregistered_trigger_count = 0; | |
82 | ||
83 | ret_code = lttng_list_triggers(&triggers); | |
84 | if (ret_code != LTTNG_OK) { | |
85 | fail("Failed to list triggers"); | |
86 | ret = -1; | |
87 | goto end; | |
88 | } | |
89 | ||
90 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
91 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
92 | fail("Failed to get count of triggers returned by listing"); | |
93 | ret = -1; | |
94 | goto end; | |
95 | } | |
96 | ||
97 | for (i = 0; i < trigger_count; i++) { | |
98 | const struct lttng_trigger *trigger; | |
99 | ||
100 | trigger = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 101 | LTTNG_ASSERT(trigger); |
2d0e6286 JG |
102 | |
103 | ret = lttng_unregister_trigger(trigger); | |
104 | if (ret) { | |
105 | fail("Failed to unregister trigger: trigger name = '%s'"); | |
106 | goto end; | |
107 | } | |
108 | ||
109 | unregistered_trigger_count++; | |
110 | } | |
111 | ||
112 | ret = (int) unregistered_trigger_count; | |
113 | ||
114 | end: | |
115 | lttng_triggers_destroy(triggers); | |
116 | return ret; | |
117 | } | |
118 | ||
119 | static | |
120 | int get_registered_triggers_count(void) | |
121 | { | |
122 | int ret; | |
123 | enum lttng_error_code ret_code; | |
124 | enum lttng_trigger_status trigger_status; | |
125 | struct lttng_triggers *triggers = NULL; | |
126 | unsigned int trigger_count; | |
127 | ||
128 | ret_code = lttng_list_triggers(&triggers); | |
129 | if (ret_code != LTTNG_OK) { | |
130 | fail("Failed to list triggers"); | |
131 | ret = -1; | |
132 | goto end; | |
133 | } | |
134 | ||
135 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
136 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
137 | fail("Failed to get count of triggers returned by listing"); | |
138 | ret = -1; | |
139 | goto end; | |
140 | } | |
141 | ||
142 | ret = (int) trigger_count; | |
143 | ||
144 | end: | |
145 | lttng_triggers_destroy(triggers); | |
146 | return ret; | |
147 | } | |
148 | ||
149 | /* | |
150 | * Create a generic trigger. The specifics of the condition and action are not | |
151 | * important for the purposes of this test. | |
152 | */ | |
153 | static | |
3eda43da | 154 | struct lttng_trigger *create_trigger(uint64_t threshold) |
2d0e6286 JG |
155 | { |
156 | struct lttng_condition *condition = NULL; | |
157 | struct lttng_action *action = NULL; | |
158 | struct lttng_trigger *trigger = NULL; | |
159 | enum lttng_condition_status condition_status; | |
160 | const char * const session_name = "test session"; | |
161 | ||
162 | condition = lttng_condition_session_consumed_size_create(); | |
163 | if (!condition) { | |
164 | fail("Failed to create 'session consumed size' condition"); | |
165 | goto end; | |
166 | } | |
167 | ||
168 | condition_status = lttng_condition_session_consumed_size_set_session_name(condition, session_name); | |
169 | if (condition_status != LTTNG_CONDITION_STATUS_OK) { | |
170 | fail("Failed to set session name on 'session consumed size' condition"); | |
171 | goto end; | |
172 | } | |
173 | ||
174 | condition_status = lttng_condition_session_consumed_size_set_threshold( | |
175 | condition, threshold); | |
176 | if (condition_status != LTTNG_CONDITION_STATUS_OK) { | |
177 | fail("Failed to set threshold on 'session consumed size' condition"); | |
178 | goto end; | |
179 | } | |
180 | ||
181 | action = lttng_action_notify_create(); | |
182 | if (!action) { | |
183 | fail("Failed to create 'notify' action"); | |
184 | goto end; | |
185 | } | |
186 | ||
187 | trigger = lttng_trigger_create(condition, action); | |
188 | if (!trigger) { | |
189 | fail("Failed to create trigger"); | |
190 | goto end; | |
191 | } | |
192 | ||
193 | end: | |
194 | lttng_condition_destroy(condition); | |
195 | lttng_action_destroy(action); | |
196 | return trigger; | |
197 | } | |
198 | ||
199 | static | |
200 | void register_anonymous_trigger( | |
201 | enum unregistration_trigger_instance unregistration_trigger) | |
202 | { | |
203 | int ret; | |
204 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
205 | enum lttng_trigger_status trigger_status; | |
206 | const char *trigger_name; | |
207 | struct lttng_triggers *triggers = NULL; | |
208 | unsigned int trigger_count, i; | |
209 | enum lttng_error_code ret_code; | |
210 | ||
211 | diag("Register an anonymous trigger (Unregistration performed with the trigger instance %s)", | |
212 | unregistration_trigger_instance_name( | |
213 | unregistration_trigger)); | |
214 | ||
215 | if (!trigger) { | |
216 | fail("Failed to create trigger"); | |
217 | goto end; | |
218 | } | |
219 | ||
220 | ret = lttng_register_trigger(trigger); | |
221 | ok(ret == 0, "Registered anonymous trigger"); | |
222 | ||
223 | trigger_status = lttng_trigger_get_name(trigger, &trigger_name); | |
224 | ok(trigger_status == LTTNG_TRIGGER_STATUS_UNSET, | |
225 | "Anonymous trigger name remains unset after registration: trigger name = '%s'", | |
226 | get_trigger_name(trigger)); | |
227 | ||
228 | ret_code = lttng_list_triggers(&triggers); | |
229 | if (ret_code != LTTNG_OK) { | |
230 | fail("Failed to list triggers"); | |
231 | ret = -1; | |
232 | goto end; | |
233 | } | |
234 | ||
235 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
236 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
237 | fail("Failed to get count of triggers returned by listing"); | |
238 | ret = -1; | |
239 | goto end; | |
240 | } | |
241 | ||
242 | ok(trigger_count == 1, "Trigger listing returns 1 trigger"); | |
243 | ||
244 | for (i = 0; i < trigger_count; i++) { | |
245 | const struct lttng_trigger *trigger_from_listing; | |
246 | ||
247 | trigger_from_listing = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 248 | LTTNG_ASSERT(trigger_from_listing); |
2d0e6286 JG |
249 | |
250 | trigger_status = lttng_trigger_get_name(trigger_from_listing, &trigger_name); | |
251 | ok(trigger_status == LTTNG_TRIGGER_STATUS_UNSET, | |
252 | "Anonymous trigger returned by listing has an unset name: trigger name = '%s'", | |
253 | get_trigger_name(trigger_from_listing)); | |
254 | ||
255 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { | |
256 | ret = lttng_unregister_trigger(trigger_from_listing); | |
257 | ok(ret == 0, "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); | |
258 | } | |
259 | } | |
260 | ||
261 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
262 | ret = lttng_unregister_trigger(trigger); | |
263 | ok(ret == 0, "Successfully unregistered anonymous trigger using the trigger instance used on registration"); | |
264 | } | |
265 | ||
266 | end: | |
267 | lttng_triggers_destroy(triggers); | |
268 | lttng_trigger_destroy(trigger); | |
269 | } | |
270 | ||
271 | static | |
272 | void register_named_trigger( | |
273 | enum unregistration_trigger_instance unregistration_trigger) | |
274 | { | |
275 | int ret; | |
276 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
277 | enum lttng_trigger_status trigger_status; | |
278 | const char *returned_trigger_name; | |
279 | struct lttng_triggers *triggers = NULL; | |
280 | unsigned int trigger_count, i; | |
281 | enum lttng_error_code ret_code; | |
282 | const char * const trigger_name = "some name that is hopefully unique"; | |
283 | ||
284 | diag("Register a named trigger (Unregistration performed with the trigger instance %s)", | |
285 | unregistration_trigger_instance_name( | |
286 | unregistration_trigger)); | |
287 | ||
288 | if (!trigger) { | |
289 | fail("Failed to create trigger"); | |
290 | goto end; | |
291 | } | |
292 | ||
293 | ret_code = lttng_register_trigger_with_name(trigger, trigger_name); | |
294 | ok(ret_code == LTTNG_OK, "Registered trigger with name: trigger name = '%s'", | |
295 | get_trigger_name(trigger)); | |
296 | ||
297 | trigger_status = lttng_trigger_get_name(trigger, &returned_trigger_name); | |
298 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, | |
299 | "Trigger name is set after registration: trigger name = '%s'", | |
300 | get_trigger_name(trigger)); | |
301 | ||
302 | ok(!strcmp(get_trigger_name(trigger), trigger_name), | |
303 | "Name set on trigger after registration is correct"); | |
304 | ||
305 | ret_code = lttng_list_triggers(&triggers); | |
306 | if (ret_code != LTTNG_OK) { | |
307 | fail("Failed to list triggers"); | |
308 | ret = -1; | |
309 | goto end; | |
310 | } | |
311 | ||
312 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
313 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
314 | fail("Failed to get count of triggers returned by listing"); | |
315 | ret = -1; | |
316 | goto end; | |
317 | } | |
318 | ||
319 | ok(trigger_count == 1, "Trigger listing returns 1 trigger"); | |
320 | ||
321 | for (i = 0; i < trigger_count; i++) { | |
322 | const struct lttng_trigger *trigger_from_listing; | |
323 | ||
324 | trigger_from_listing = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 325 | LTTNG_ASSERT(trigger_from_listing); |
2d0e6286 JG |
326 | |
327 | trigger_status = lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); | |
328 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, | |
329 | "Trigger returned by listing has a name: trigger name = '%s'", | |
330 | get_trigger_name(trigger_from_listing)); | |
331 | ||
332 | ok(!strcmp(get_trigger_name(trigger_from_listing), | |
333 | trigger_name), | |
334 | "Name set on trigger returned from listing is correct: name returned from listing = '%s', expected name = '%s'", | |
335 | get_trigger_name(trigger_from_listing), | |
336 | trigger_name); | |
337 | ||
338 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { | |
339 | ret = lttng_unregister_trigger(trigger_from_listing); | |
340 | ok(ret == 0, "Successfully unregistered named trigger using the trigger instance returned by the listing"); | |
341 | } | |
342 | } | |
343 | ||
344 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
345 | ret = lttng_unregister_trigger(trigger); | |
346 | ok(ret == 0, "Successfully unregistered named trigger using the trigger instance used on registration"); | |
347 | } | |
348 | ||
349 | end: | |
350 | lttng_triggers_destroy(triggers); | |
351 | lttng_trigger_destroy(trigger); | |
352 | } | |
353 | ||
354 | static | |
355 | void register_automatic_name_trigger( | |
356 | enum unregistration_trigger_instance unregistration_trigger) | |
357 | { | |
358 | int ret; | |
359 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
360 | enum lttng_trigger_status trigger_status; | |
361 | const char *returned_trigger_name; | |
362 | struct lttng_triggers *triggers = NULL; | |
363 | unsigned int trigger_count, i; | |
364 | enum lttng_error_code ret_code; | |
365 | ||
366 | diag("Register an automatic name trigger (Unregistration performed with the trigger instance %s)", | |
367 | unregistration_trigger_instance_name( | |
368 | unregistration_trigger)); | |
369 | ||
370 | if (!trigger) { | |
371 | fail("Failed to create trigger"); | |
372 | goto end; | |
373 | } | |
374 | ||
375 | ret_code = lttng_register_trigger_with_automatic_name(trigger); | |
376 | ok(ret_code == LTTNG_OK, "Registered trigger with automatic name"); | |
377 | ||
378 | trigger_status = lttng_trigger_get_name(trigger, &returned_trigger_name); | |
379 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, | |
380 | "Trigger name is set after registration: trigger name = '%s'", | |
381 | get_trigger_name(trigger)); | |
382 | ||
383 | ok(returned_trigger_name && strlen(returned_trigger_name) > 0, | |
384 | "Automatic name set on trigger after registration longer is not an empty string"); | |
385 | ||
386 | ret_code = lttng_list_triggers(&triggers); | |
387 | if (ret_code != LTTNG_OK) { | |
388 | fail("Failed to list triggers"); | |
389 | ret = -1; | |
390 | goto end; | |
391 | } | |
392 | ||
393 | trigger_status = lttng_triggers_get_count(triggers, &trigger_count); | |
394 | if (trigger_status != LTTNG_TRIGGER_STATUS_OK) { | |
395 | fail("Failed to get count of triggers returned by listing"); | |
396 | ret = -1; | |
397 | goto end; | |
398 | } | |
399 | ||
400 | ok(trigger_count == 1, "Trigger listing returns 1 trigger"); | |
401 | ||
402 | for (i = 0; i < trigger_count; i++) { | |
403 | const struct lttng_trigger *trigger_from_listing; | |
404 | ||
405 | trigger_from_listing = lttng_triggers_get_at_index(triggers, i); | |
a0377dfe | 406 | LTTNG_ASSERT(trigger_from_listing); |
2d0e6286 JG |
407 | |
408 | trigger_status = lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); | |
409 | ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, | |
410 | "Trigger returned by listing has a name: trigger name = '%s'", | |
411 | get_trigger_name(trigger_from_listing)); | |
412 | ||
413 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { | |
414 | ret = lttng_unregister_trigger(trigger_from_listing); | |
415 | ok(ret == 0, "Successfully unregistered automatic name trigger using the trigger instance returned by the listing"); | |
416 | } | |
417 | } | |
418 | ||
419 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
420 | ret = lttng_unregister_trigger(trigger); | |
421 | ok(ret == 0, "Successfully unregistered automatic trigger using the trigger instance used on registration"); | |
422 | } | |
423 | ||
424 | end: | |
425 | lttng_triggers_destroy(triggers); | |
426 | lttng_trigger_destroy(trigger); | |
427 | } | |
428 | ||
429 | static | |
430 | void double_register_anonymous_trigger( | |
431 | enum unregistration_trigger_instance unregistration_trigger) | |
432 | { | |
433 | int ret; | |
434 | struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); | |
435 | struct lttng_triggers *triggers = NULL; | |
436 | ||
437 | diag("Register duplicate anonymous trigger (Unregistration performed with the trigger instance %s)", | |
438 | unregistration_trigger_instance_name( | |
439 | unregistration_trigger)); | |
440 | ||
441 | if (!trigger) { | |
442 | fail("Failed to create trigger"); | |
443 | goto end; | |
444 | } | |
445 | ||
446 | ret = lttng_register_trigger(trigger); | |
447 | ok(ret == 0, "Registered anonymous trigger"); | |
448 | ||
449 | ret = lttng_register_trigger(trigger); | |
450 | ok(ret == -LTTNG_ERR_TRIGGER_EXISTS, | |
451 | "Registering identical anonymous trigger fails with `LTTNG_ERR_TRIGGER_EXISTS`"); | |
452 | ||
453 | ||
454 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
455 | ret = lttng_unregister_trigger(trigger); | |
456 | ok(ret == 0, "Successfully unregistered anonymous trigger using the trigger instance used on registration"); | |
457 | } else { | |
458 | ok(get_registered_triggers_count() == 1, | |
459 | "Trigger listing returns 1 trigger"); | |
460 | ok(unregister_all_triggers() == 1, | |
461 | "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); | |
462 | } | |
463 | ||
464 | end: | |
465 | lttng_triggers_destroy(triggers); | |
466 | lttng_trigger_destroy(trigger); | |
467 | } | |
468 | ||
469 | static | |
470 | void double_register_named_trigger( | |
471 | enum unregistration_trigger_instance unregistration_trigger) | |
472 | { | |
473 | int ret; | |
474 | struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); | |
475 | struct lttng_trigger *trigger_b = create_trigger(0xbadc0ffee); | |
476 | struct lttng_triggers *triggers = NULL; | |
477 | const char * const trigger_name = "a unique trigger name"; | |
478 | enum lttng_error_code ret_code; | |
479 | ||
480 | diag("Register duplicate named trigger (Unregistration performed with the trigger instance %s)", | |
481 | unregistration_trigger_instance_name( | |
482 | unregistration_trigger)); | |
483 | ||
484 | if (!trigger_a || !trigger_b) { | |
485 | fail("Failed to create triggers"); | |
486 | goto end; | |
487 | } | |
488 | ||
489 | ret_code = lttng_register_trigger_with_name(trigger_a, trigger_name); | |
490 | ok(ret_code == LTTNG_OK, "Registered named trigger"); | |
491 | ||
492 | ret = lttng_register_trigger(trigger_a); | |
493 | ok(ret == -LTTNG_ERR_INVALID, | |
494 | "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (anonymous registration)"); | |
495 | ||
496 | ret_code = lttng_register_trigger_with_name(trigger_a, trigger_name); | |
497 | ok(ret_code == LTTNG_ERR_INVALID, | |
498 | "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with name)"); | |
499 | ||
500 | ret_code = lttng_register_trigger_with_automatic_name(trigger_a); | |
501 | ok(ret_code == LTTNG_ERR_INVALID, | |
502 | "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with automatic name)"); | |
503 | ||
504 | ret_code = lttng_register_trigger_with_name(trigger_b, trigger_name); | |
505 | ok(ret_code == LTTNG_ERR_TRIGGER_EXISTS, "Registering trigger with an already used name fails with `LTTNG_ERR_TRIGGER_EXISTS`"); | |
506 | ||
507 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
508 | ret = lttng_unregister_trigger(trigger_a); | |
509 | ok(ret == 0, "Successfully unregistered named trigger using the trigger instance used on registration"); | |
510 | } else { | |
511 | ok(get_registered_triggers_count() == 1, | |
512 | "Trigger listing returns 1 trigger"); | |
513 | ok(unregister_all_triggers() == 1, | |
514 | "Successfully unregistered named trigger using the trigger instance returned by the listing"); | |
515 | } | |
516 | ||
517 | end: | |
518 | lttng_triggers_destroy(triggers); | |
519 | lttng_trigger_destroy(trigger_a); | |
520 | lttng_trigger_destroy(trigger_b); | |
521 | } | |
522 | ||
523 | static | |
524 | void double_register_automatic_name_trigger( | |
525 | enum unregistration_trigger_instance unregistration_trigger) | |
526 | { | |
527 | int ret; | |
528 | struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); | |
529 | struct lttng_trigger *trigger_b = create_trigger(0xbadc0ffee); | |
530 | struct lttng_triggers *triggers = NULL; | |
531 | enum lttng_error_code ret_code; | |
532 | ||
533 | diag("Register duplicate automatic name trigger (Unregistration performed with the trigger instance %s)", | |
534 | unregistration_trigger_instance_name( | |
535 | unregistration_trigger)); | |
536 | ||
537 | if (!trigger_a || !trigger_b) { | |
538 | fail("Failed to create triggers"); | |
539 | goto end; | |
540 | } | |
541 | ||
542 | ret_code = lttng_register_trigger_with_automatic_name(trigger_a); | |
543 | ok(ret_code == LTTNG_OK, "Registered automatic name trigger: trigger name = '%s'", get_trigger_name(trigger_a)); | |
544 | ||
545 | ret = lttng_register_trigger_with_automatic_name(trigger_b); | |
546 | ok(ret_code == LTTNG_OK, "Registering an identical trigger instance with an automatic name succeeds: trigger name = '%s'", get_trigger_name(trigger_b)); | |
547 | ||
548 | ok(strcmp(get_trigger_name(trigger_a), get_trigger_name(trigger_b)), | |
549 | "Two identical triggers registered with an automatic name have different names"); | |
550 | ||
551 | if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { | |
552 | ret = lttng_unregister_trigger(trigger_a); | |
553 | ok(ret == 0, "Successfully unregistered automatic trigger A using the trigger instance used on registration"); | |
554 | ||
555 | ret = lttng_unregister_trigger(trigger_b); | |
556 | ok(ret == 0, "Successfully unregistered automatic trigger B using the trigger instance used on registration"); | |
557 | } else { | |
558 | ok(get_registered_triggers_count() == 2, | |
559 | "Trigger listing returns 2 trigger"); | |
560 | ok(unregister_all_triggers() == 2, | |
561 | "Successfully unregistered automatic name triggers using the trigger instance returned by the listing"); | |
562 | } | |
563 | ||
564 | end: | |
565 | lttng_triggers_destroy(triggers); | |
566 | lttng_trigger_destroy(trigger_a); | |
567 | lttng_trigger_destroy(trigger_b); | |
568 | } | |
569 | ||
570 | static | |
571 | void register_multiple_anonymous_triggers(void) | |
572 | { | |
573 | int ret; | |
574 | struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); | |
575 | struct lttng_trigger *trigger_b = create_trigger(0xbadf00d); | |
576 | ||
577 | diag("Register two different anonymous triggers"); | |
578 | ||
579 | if (!trigger_a || !trigger_b) { | |
580 | fail("Failed to create triggers"); | |
581 | goto end; | |
582 | } | |
583 | ||
584 | ret = lttng_register_trigger(trigger_a); | |
585 | ok(ret == 0, "Registered first anonymous trigger"); | |
586 | ||
587 | ret = lttng_register_trigger(trigger_b); | |
588 | ok(ret == 0, "Registered second anonymous trigger"); | |
589 | ||
590 | ok(get_registered_triggers_count() == 2, | |
591 | "Trigger listing returns 2 trigger"); | |
592 | ok(unregister_all_triggers() == 2, | |
593 | "Successfully unregistered two anonymous triggers"); | |
594 | ||
595 | end: | |
596 | lttng_trigger_destroy(trigger_a); | |
597 | lttng_trigger_destroy(trigger_b); | |
598 | } | |
599 | ||
600 | const test_function test_functions[] = { | |
601 | register_anonymous_trigger, | |
602 | register_named_trigger, | |
603 | register_automatic_name_trigger, | |
604 | double_register_anonymous_trigger, | |
605 | double_register_named_trigger, | |
606 | double_register_automatic_name_trigger, | |
607 | }; | |
608 | ||
609 | int main(int argc, const char **argv) | |
610 | { | |
611 | size_t i; | |
612 | ||
613 | plan_tests(TEST_COUNT); | |
614 | ||
615 | if (get_registered_triggers_count() != 0) { | |
616 | fail("Session daemon already has registered triggers, bailing out"); | |
617 | goto end; | |
618 | } | |
619 | ||
620 | for (i = 0; i < ARRAY_SIZE(test_functions); i++) { | |
621 | const test_function fn = test_functions[i]; | |
622 | ||
623 | fn(UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING); | |
624 | if (get_registered_triggers_count() != 0) { | |
625 | fail("Previous test left registered triggers, bailing out"); | |
626 | goto end; | |
627 | } | |
628 | } | |
629 | ||
630 | for (i = 0; i < ARRAY_SIZE(test_functions); i++) { | |
631 | const test_function fn = test_functions[i]; | |
632 | ||
633 | fn(UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION); | |
634 | if (get_registered_triggers_count() != 0) { | |
635 | fail("Previous test left registered triggers, bailing out"); | |
636 | goto end; | |
637 | } | |
638 | } | |
639 | ||
640 | register_multiple_anonymous_triggers(); | |
641 | end: | |
642 | return exit_status(); | |
643 | } |