X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=tests%2Fregression%2Ftools%2Ftrigger%2Fname%2Ftrigger_name.cpp;h=b878af48639771979821777821aec3df4548183e;hb=cd9adb8b829564212158943a0d279bb35322ab30;hp=3bb3099ce860659749979250ed9184476fda678b;hpb=729c1fec5976af17fded2f026725a08ef1924290;p=lttng-tools.git diff --git a/tests/regression/tools/trigger/name/trigger_name.cpp b/tests/regression/tools/trigger/name/trigger_name.cpp index 3bb3099ce..b878af486 100644 --- a/tests/regression/tools/trigger/name/trigger_name.cpp +++ b/tests/regression/tools/trigger/name/trigger_name.cpp @@ -9,13 +9,15 @@ * */ -#include -#include -#include +#include + +#include + #include +#include #include -#include -#include +#include +#include #define TEST_COUNT 70 @@ -24,10 +26,9 @@ enum unregistration_trigger_instance { UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING, }; -typedef void (*test_function)(enum unregistration_trigger_instance); +using test_function = void (*)(enum unregistration_trigger_instance); -static -const char *get_trigger_name(const struct lttng_trigger *trigger) +static const char *get_trigger_name(const struct lttng_trigger *trigger) { const char *trigger_name; enum lttng_trigger_status trigger_status; @@ -47,9 +48,8 @@ const char *get_trigger_name(const struct lttng_trigger *trigger) return trigger_name; } -static -const char *unregistration_trigger_instance_name( - enum unregistration_trigger_instance unregistration_trigger) +static const char * +unregistration_trigger_instance_name(enum unregistration_trigger_instance unregistration_trigger) { const char *name; @@ -71,13 +71,12 @@ const char *unregistration_trigger_instance_name( * Returns a negative error code on error, else the number of unregistered * triggers. */ -static -int unregister_all_triggers(void) +static int unregister_all_triggers() { int ret; enum lttng_error_code ret_code; enum lttng_trigger_status trigger_status; - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; unsigned int trigger_count, i, unregistered_trigger_count = 0; ret_code = lttng_list_triggers(&triggers); @@ -102,7 +101,14 @@ int unregister_all_triggers(void) ret = lttng_unregister_trigger(trigger); if (ret) { - fail("Failed to unregister trigger: trigger name = '%s'"); + const char *name; + enum lttng_trigger_status get_name_status = + lttng_trigger_get_name(trigger, &name); + if (get_name_status == LTTNG_TRIGGER_STATUS_OK) { + fail("Failed to unregister trigger: trigger name = '%s'", name); + } else { + fail("Failed to unregister trigger"); + } goto end; } @@ -116,13 +122,12 @@ end: return ret; } -static -int get_registered_triggers_count(void) +static int get_registered_triggers_count() { int ret; enum lttng_error_code ret_code; enum lttng_trigger_status trigger_status; - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; unsigned int trigger_count; ret_code = lttng_list_triggers(&triggers); @@ -150,14 +155,13 @@ end: * Create a generic trigger. The specifics of the condition and action are not * important for the purposes of this test. */ -static -struct lttng_trigger *create_trigger(uint64_t threshold) +static struct lttng_trigger *create_trigger(uint64_t threshold) { - struct lttng_condition *condition = NULL; - struct lttng_action *action = NULL; - struct lttng_trigger *trigger = NULL; + struct lttng_condition *condition = nullptr; + struct lttng_action *action = nullptr; + struct lttng_trigger *trigger = nullptr; enum lttng_condition_status condition_status; - const char * const session_name = "test session"; + const char *const session_name = "test session"; condition = lttng_condition_session_consumed_size_create(); if (!condition) { @@ -165,14 +169,15 @@ struct lttng_trigger *create_trigger(uint64_t threshold) goto end; } - condition_status = lttng_condition_session_consumed_size_set_session_name(condition, session_name); + condition_status = + lttng_condition_session_consumed_size_set_session_name(condition, session_name); if (condition_status != LTTNG_CONDITION_STATUS_OK) { fail("Failed to set session name on 'session consumed size' condition"); goto end; } - condition_status = lttng_condition_session_consumed_size_set_threshold( - condition, threshold); + condition_status = + lttng_condition_session_consumed_size_set_threshold(condition, threshold); if (condition_status != LTTNG_CONDITION_STATUS_OK) { fail("Failed to set threshold on 'session consumed size' condition"); goto end; @@ -196,21 +201,18 @@ end: return trigger; } -static -void register_anonymous_trigger( - enum unregistration_trigger_instance unregistration_trigger) +static void register_anonymous_trigger(enum unregistration_trigger_instance unregistration_trigger) { int ret; struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); enum lttng_trigger_status trigger_status; const char *trigger_name; - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; unsigned int trigger_count, i; enum lttng_error_code ret_code; diag("Register an anonymous trigger (Unregistration performed with the trigger instance %s)", - unregistration_trigger_instance_name( - unregistration_trigger)); + unregistration_trigger_instance_name(unregistration_trigger)); if (!trigger) { fail("Failed to create trigger"); @@ -222,8 +224,8 @@ void register_anonymous_trigger( trigger_status = lttng_trigger_get_name(trigger, &trigger_name); ok(trigger_status == LTTNG_TRIGGER_STATUS_UNSET, - "Anonymous trigger name remains unset after registration: trigger name = '%s'", - get_trigger_name(trigger)); + "Anonymous trigger name remains unset after registration: trigger name = '%s'", + get_trigger_name(trigger)); ret_code = lttng_list_triggers(&triggers); if (ret_code != LTTNG_OK) { @@ -249,18 +251,20 @@ void register_anonymous_trigger( trigger_status = lttng_trigger_get_name(trigger_from_listing, &trigger_name); ok(trigger_status == LTTNG_TRIGGER_STATUS_UNSET, - "Anonymous trigger returned by listing has an unset name: trigger name = '%s'", - get_trigger_name(trigger_from_listing)); + "Anonymous trigger returned by listing has an unset name: trigger name = '%s'", + get_trigger_name(trigger_from_listing)); if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { ret = lttng_unregister_trigger(trigger_from_listing); - ok(ret == 0, "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); + ok(ret == 0, + "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); } } if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { ret = lttng_unregister_trigger(trigger); - ok(ret == 0, "Successfully unregistered anonymous trigger using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered anonymous trigger using the trigger instance used on registration"); } end: @@ -268,22 +272,19 @@ end: lttng_trigger_destroy(trigger); } -static -void register_named_trigger( - enum unregistration_trigger_instance unregistration_trigger) +static void register_named_trigger(enum unregistration_trigger_instance unregistration_trigger) { int ret; struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); enum lttng_trigger_status trigger_status; const char *returned_trigger_name; - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; unsigned int trigger_count, i; enum lttng_error_code ret_code; - const char * const trigger_name = "some name that is hopefully unique"; + const char *const trigger_name = "some name that is hopefully unique"; diag("Register a named trigger (Unregistration performed with the trigger instance %s)", - unregistration_trigger_instance_name( - unregistration_trigger)); + unregistration_trigger_instance_name(unregistration_trigger)); if (!trigger) { fail("Failed to create trigger"); @@ -291,16 +292,17 @@ void register_named_trigger( } ret_code = lttng_register_trigger_with_name(trigger, trigger_name); - ok(ret_code == LTTNG_OK, "Registered trigger with name: trigger name = '%s'", - get_trigger_name(trigger)); + ok(ret_code == LTTNG_OK, + "Registered trigger with name: trigger name = '%s'", + get_trigger_name(trigger)); trigger_status = lttng_trigger_get_name(trigger, &returned_trigger_name); ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, - "Trigger name is set after registration: trigger name = '%s'", - get_trigger_name(trigger)); + "Trigger name is set after registration: trigger name = '%s'", + get_trigger_name(trigger)); ok(!strcmp(get_trigger_name(trigger), trigger_name), - "Name set on trigger after registration is correct"); + "Name set on trigger after registration is correct"); ret_code = lttng_list_triggers(&triggers); if (ret_code != LTTNG_OK) { @@ -324,26 +326,28 @@ void register_named_trigger( trigger_from_listing = lttng_triggers_get_at_index(triggers, i); LTTNG_ASSERT(trigger_from_listing); - trigger_status = lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); + trigger_status = + lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, - "Trigger returned by listing has a name: trigger name = '%s'", - get_trigger_name(trigger_from_listing)); + "Trigger returned by listing has a name: trigger name = '%s'", + get_trigger_name(trigger_from_listing)); - ok(!strcmp(get_trigger_name(trigger_from_listing), - trigger_name), - "Name set on trigger returned from listing is correct: name returned from listing = '%s', expected name = '%s'", - get_trigger_name(trigger_from_listing), - trigger_name); + ok(!strcmp(get_trigger_name(trigger_from_listing), trigger_name), + "Name set on trigger returned from listing is correct: name returned from listing = '%s', expected name = '%s'", + get_trigger_name(trigger_from_listing), + trigger_name); if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { ret = lttng_unregister_trigger(trigger_from_listing); - ok(ret == 0, "Successfully unregistered named trigger using the trigger instance returned by the listing"); + ok(ret == 0, + "Successfully unregistered named trigger using the trigger instance returned by the listing"); } } if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { ret = lttng_unregister_trigger(trigger); - ok(ret == 0, "Successfully unregistered named trigger using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered named trigger using the trigger instance used on registration"); } end: @@ -351,21 +355,19 @@ end: lttng_trigger_destroy(trigger); } -static -void register_automatic_name_trigger( - enum unregistration_trigger_instance unregistration_trigger) +static void +register_automatic_name_trigger(enum unregistration_trigger_instance unregistration_trigger) { int ret; struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); enum lttng_trigger_status trigger_status; const char *returned_trigger_name; - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; unsigned int trigger_count, i; enum lttng_error_code ret_code; diag("Register an automatic name trigger (Unregistration performed with the trigger instance %s)", - unregistration_trigger_instance_name( - unregistration_trigger)); + unregistration_trigger_instance_name(unregistration_trigger)); if (!trigger) { fail("Failed to create trigger"); @@ -377,11 +379,11 @@ void register_automatic_name_trigger( trigger_status = lttng_trigger_get_name(trigger, &returned_trigger_name); ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, - "Trigger name is set after registration: trigger name = '%s'", - get_trigger_name(trigger)); + "Trigger name is set after registration: trigger name = '%s'", + get_trigger_name(trigger)); ok(returned_trigger_name && strlen(returned_trigger_name) > 0, - "Automatic name set on trigger after registration longer is not an empty string"); + "Automatic name set on trigger after registration longer is not an empty string"); ret_code = lttng_list_triggers(&triggers); if (ret_code != LTTNG_OK) { @@ -405,20 +407,23 @@ void register_automatic_name_trigger( trigger_from_listing = lttng_triggers_get_at_index(triggers, i); LTTNG_ASSERT(trigger_from_listing); - trigger_status = lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); + trigger_status = + lttng_trigger_get_name(trigger_from_listing, &returned_trigger_name); ok(trigger_status == LTTNG_TRIGGER_STATUS_OK, - "Trigger returned by listing has a name: trigger name = '%s'", - get_trigger_name(trigger_from_listing)); + "Trigger returned by listing has a name: trigger name = '%s'", + get_trigger_name(trigger_from_listing)); if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_FROM_LISTING) { ret = lttng_unregister_trigger(trigger_from_listing); - ok(ret == 0, "Successfully unregistered automatic name trigger using the trigger instance returned by the listing"); + ok(ret == 0, + "Successfully unregistered automatic name trigger using the trigger instance returned by the listing"); } } if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { ret = lttng_unregister_trigger(trigger); - ok(ret == 0, "Successfully unregistered automatic trigger using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered automatic trigger using the trigger instance used on registration"); } end: @@ -426,17 +431,15 @@ end: lttng_trigger_destroy(trigger); } -static -void double_register_anonymous_trigger( - enum unregistration_trigger_instance unregistration_trigger) +static void +double_register_anonymous_trigger(enum unregistration_trigger_instance unregistration_trigger) { int ret; struct lttng_trigger *trigger = create_trigger(0xbadc0ffee); - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; diag("Register duplicate anonymous trigger (Unregistration performed with the trigger instance %s)", - unregistration_trigger_instance_name( - unregistration_trigger)); + unregistration_trigger_instance_name(unregistration_trigger)); if (!trigger) { fail("Failed to create trigger"); @@ -448,17 +451,16 @@ void double_register_anonymous_trigger( ret = lttng_register_trigger(trigger); ok(ret == -LTTNG_ERR_TRIGGER_EXISTS, - "Registering identical anonymous trigger fails with `LTTNG_ERR_TRIGGER_EXISTS`"); - + "Registering identical anonymous trigger fails with `LTTNG_ERR_TRIGGER_EXISTS`"); if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { ret = lttng_unregister_trigger(trigger); - ok(ret == 0, "Successfully unregistered anonymous trigger using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered anonymous trigger using the trigger instance used on registration"); } else { - ok(get_registered_triggers_count() == 1, - "Trigger listing returns 1 trigger"); + ok(get_registered_triggers_count() == 1, "Trigger listing returns 1 trigger"); ok(unregister_all_triggers() == 1, - "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); + "Successfully unregistered anonymous trigger using the trigger instance returned by the listing"); } end: @@ -466,20 +468,18 @@ end: lttng_trigger_destroy(trigger); } -static -void double_register_named_trigger( - enum unregistration_trigger_instance unregistration_trigger) +static void +double_register_named_trigger(enum unregistration_trigger_instance unregistration_trigger) { int ret; struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); struct lttng_trigger *trigger_b = create_trigger(0xbadc0ffee); - struct lttng_triggers *triggers = NULL; - const char * const trigger_name = "a unique trigger name"; + struct lttng_triggers *triggers = nullptr; + const char *const trigger_name = "a unique trigger name"; enum lttng_error_code ret_code; diag("Register duplicate named trigger (Unregistration performed with the trigger instance %s)", - unregistration_trigger_instance_name( - unregistration_trigger)); + unregistration_trigger_instance_name(unregistration_trigger)); if (!trigger_a || !trigger_b) { fail("Failed to create triggers"); @@ -491,27 +491,28 @@ void double_register_named_trigger( ret = lttng_register_trigger(trigger_a); ok(ret == -LTTNG_ERR_INVALID, - "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (anonymous registration)"); + "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (anonymous registration)"); ret_code = lttng_register_trigger_with_name(trigger_a, trigger_name); ok(ret_code == LTTNG_ERR_INVALID, - "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with name)"); + "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with name)"); ret_code = lttng_register_trigger_with_automatic_name(trigger_a); ok(ret_code == LTTNG_ERR_INVALID, - "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with automatic name)"); + "Registering a trigger instance already used for registration fails with `LTTNG_ERR_INVALID` (register with automatic name)"); ret_code = lttng_register_trigger_with_name(trigger_b, trigger_name); - ok(ret_code == LTTNG_ERR_TRIGGER_EXISTS, "Registering trigger with an already used name fails with `LTTNG_ERR_TRIGGER_EXISTS`"); + ok(ret_code == LTTNG_ERR_TRIGGER_EXISTS, + "Registering trigger with an already used name fails with `LTTNG_ERR_TRIGGER_EXISTS`"); if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { ret = lttng_unregister_trigger(trigger_a); - ok(ret == 0, "Successfully unregistered named trigger using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered named trigger using the trigger instance used on registration"); } else { - ok(get_registered_triggers_count() == 1, - "Trigger listing returns 1 trigger"); + ok(get_registered_triggers_count() == 1, "Trigger listing returns 1 trigger"); ok(unregister_all_triggers() == 1, - "Successfully unregistered named trigger using the trigger instance returned by the listing"); + "Successfully unregistered named trigger using the trigger instance returned by the listing"); } end: @@ -520,19 +521,17 @@ end: lttng_trigger_destroy(trigger_b); } -static -void double_register_automatic_name_trigger( - enum unregistration_trigger_instance unregistration_trigger) +static void +double_register_automatic_name_trigger(enum unregistration_trigger_instance unregistration_trigger) { int ret; struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); struct lttng_trigger *trigger_b = create_trigger(0xbadc0ffee); - struct lttng_triggers *triggers = NULL; + struct lttng_triggers *triggers = nullptr; enum lttng_error_code ret_code; diag("Register duplicate automatic name trigger (Unregistration performed with the trigger instance %s)", - unregistration_trigger_instance_name( - unregistration_trigger)); + unregistration_trigger_instance_name(unregistration_trigger)); if (!trigger_a || !trigger_b) { fail("Failed to create triggers"); @@ -540,25 +539,30 @@ void double_register_automatic_name_trigger( } ret_code = lttng_register_trigger_with_automatic_name(trigger_a); - ok(ret_code == LTTNG_OK, "Registered automatic name trigger: trigger name = '%s'", get_trigger_name(trigger_a)); + ok(ret_code == LTTNG_OK, + "Registered automatic name trigger: trigger name = '%s'", + get_trigger_name(trigger_a)); ret = lttng_register_trigger_with_automatic_name(trigger_b); - ok(ret_code == LTTNG_OK, "Registering an identical trigger instance with an automatic name succeeds: trigger name = '%s'", get_trigger_name(trigger_b)); + ok(ret_code == LTTNG_OK, + "Registering an identical trigger instance with an automatic name succeeds: trigger name = '%s'", + get_trigger_name(trigger_b)); ok(strcmp(get_trigger_name(trigger_a), get_trigger_name(trigger_b)), - "Two identical triggers registered with an automatic name have different names"); + "Two identical triggers registered with an automatic name have different names"); if (unregistration_trigger == UNREGISTRATION_TRIGGER_INSTANCE_USED_FOR_REGISTRATION) { ret = lttng_unregister_trigger(trigger_a); - ok(ret == 0, "Successfully unregistered automatic trigger A using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered automatic trigger A using the trigger instance used on registration"); ret = lttng_unregister_trigger(trigger_b); - ok(ret == 0, "Successfully unregistered automatic trigger B using the trigger instance used on registration"); + ok(ret == 0, + "Successfully unregistered automatic trigger B using the trigger instance used on registration"); } else { - ok(get_registered_triggers_count() == 2, - "Trigger listing returns 2 trigger"); + ok(get_registered_triggers_count() == 2, "Trigger listing returns 2 trigger"); ok(unregister_all_triggers() == 2, - "Successfully unregistered automatic name triggers using the trigger instance returned by the listing"); + "Successfully unregistered automatic name triggers using the trigger instance returned by the listing"); } end: @@ -567,8 +571,7 @@ end: lttng_trigger_destroy(trigger_b); } -static -void register_multiple_anonymous_triggers(void) +static void register_multiple_anonymous_triggers() { int ret; struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); @@ -587,10 +590,8 @@ void register_multiple_anonymous_triggers(void) ret = lttng_register_trigger(trigger_b); ok(ret == 0, "Registered second anonymous trigger"); - ok(get_registered_triggers_count() == 2, - "Trigger listing returns 2 trigger"); - ok(unregister_all_triggers() == 2, - "Successfully unregistered two anonymous triggers"); + ok(get_registered_triggers_count() == 2, "Trigger listing returns 2 trigger"); + ok(unregister_all_triggers() == 2, "Successfully unregistered two anonymous triggers"); end: lttng_trigger_destroy(trigger_a); @@ -598,15 +599,12 @@ end: } const test_function test_functions[] = { - register_anonymous_trigger, - register_named_trigger, - register_automatic_name_trigger, - double_register_anonymous_trigger, - double_register_named_trigger, - double_register_automatic_name_trigger, + register_anonymous_trigger, register_named_trigger, + register_automatic_name_trigger, double_register_anonymous_trigger, + double_register_named_trigger, double_register_automatic_name_trigger, }; -int main(int argc, const char **argv) +int main() { size_t i;