X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=tests%2Fregression%2Ftools%2Ftrigger%2Fname%2Ftrigger_name.cpp;fp=tests%2Fregression%2Ftools%2Ftrigger%2Fname%2Ftrigger_name.cpp;h=80bd96c27b9f893d2c340d166ba94a0079c22745;hp=1e2a676dc4000003eec31a6eccb2736ff5d2c42f;hb=28ab034a2c3582d07d3423d2d746731f87d3969f;hpb=52e345b9ac912d033c2a2c25a170a01cf209839d diff --git a/tests/regression/tools/trigger/name/trigger_name.cpp b/tests/regression/tools/trigger/name/trigger_name.cpp index 1e2a676dc..80bd96c27 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 @@ -26,8 +28,7 @@ enum unregistration_trigger_instance { typedef void (*test_function)(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,8 +71,7 @@ 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(void) { int ret; enum lttng_error_code ret_code; @@ -123,8 +122,7 @@ end: return ret; } -static -int get_registered_triggers_count(void) +static int get_registered_triggers_count(void) { int ret; enum lttng_error_code ret_code; @@ -157,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; 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) { @@ -172,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; @@ -203,9 +201,7 @@ 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); @@ -216,8 +212,7 @@ void register_anonymous_trigger( 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"); @@ -229,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) { @@ -256,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: @@ -275,9 +272,7 @@ 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); @@ -286,11 +281,10 @@ void register_named_trigger( struct lttng_triggers *triggers = NULL; 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"); @@ -298,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) { @@ -331,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: @@ -358,9 +355,8 @@ 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); @@ -371,8 +367,7 @@ void register_automatic_name_trigger( 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"); @@ -384,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) { @@ -412,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: @@ -433,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; 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"); @@ -455,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: @@ -473,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"; + 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"); @@ -498,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: @@ -527,9 +521,8 @@ 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); @@ -538,8 +531,7 @@ void double_register_automatic_name_trigger( 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"); @@ -547,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: @@ -574,8 +571,7 @@ end: lttng_trigger_destroy(trigger_b); } -static -void register_multiple_anonymous_triggers(void) +static void register_multiple_anonymous_triggers(void) { int ret; struct lttng_trigger *trigger_a = create_trigger(0xbadc0ffee); @@ -594,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); @@ -605,12 +599,9 @@ 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(void)