*
*/
-#include <stdio.h>
-#include <unistd.h>
-#include <tap/tap.h>
+#include <common/macros.hpp>
+
+#include <lttng/lttng.h>
+
#include <stdint.h>
+#include <stdio.h>
#include <string.h>
-#include <lttng/lttng.h>
-#include <common/macros.hpp>
+#include <tap/tap.h>
+#include <unistd.h>
#define TEST_COUNT 70
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;
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;
* 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;
return ret;
}
-static
-int get_registered_triggers_count(void)
+static int get_registered_triggers_count(void)
{
int ret;
enum lttng_error_code ret_code;
* 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) {
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;
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_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");
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) {
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:
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);
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");
}
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) {
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:
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_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");
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) {
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:
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");
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:
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");
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:
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);
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");
}
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:
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);
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);
}
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)
projects / lttng-tools.git / blobdiff