[lttng-tools.git] / tests / unit / test_action.c

/*
 * test_action.c
 *
 * Unit tests for the notification API.
 *
 * Copyright (C) 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
 *
 * SPDX-License-Identifier: MIT
 *
 */

#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include <tap/tap.h>

#include <common/payload-view.h>
#include <common/payload.h>
#include <lttng/action/action-internal.h>
#include <lttng/action/action.h>
#include <lttng/action/notify.h>
#include <lttng/action/rate-policy-internal.h>
#include <lttng/action/rate-policy.h>
#include <lttng/action/rotate-session.h>
#include <lttng/action/snapshot-session.h>
#include <lttng/action/start-session.h>
#include <lttng/action/stop-session.h>

/* For error.h */
int lttng_opt_quiet = 1;
int lttng_opt_verbose;
int lttng_opt_mi;

#define NUM_TESTS 60

static void test_action_notify(void)
{
	int ret;
	enum lttng_action_status status;
	struct lttng_action *notify_action = NULL,
			    *notify_action_from_buffer = NULL;
	struct lttng_rate_policy *policy = NULL, *default_policy;
	struct lttng_payload payload;

	lttng_payload_init(&payload);

	/* To set. */
	policy = lttng_rate_policy_every_n_create(100);
	/* For comparison. */
	default_policy = lttng_rate_policy_every_n_create(1);

	assert(policy && default_policy);

	notify_action = lttng_action_notify_create();
	ok(notify_action, "Create notify action");
	ok(lttng_action_get_type(notify_action) == LTTNG_ACTION_TYPE_NOTIFY,
			"Action has type LTTNG_ACTION_TYPE_NOTIFY");

	/* Validate the default policy for a notify action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_notify_get_rate_policy(
				notify_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								default_policy,
								cur_policy),
				"Default policy is every n=1");
	}

	/* Set a custom policy. */
	status = lttng_action_notify_set_rate_policy(notify_action, policy);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");

	/* Validate the custom policy for a notify action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_notify_get_rate_policy(
				notify_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								policy,
								cur_policy),
				"Notify action policy get");
	}

	ret = lttng_action_serialize(notify_action, &payload);
	ok(ret == 0, "Action notify serialized");

	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);
		(void) lttng_action_create_from_payload(
				&view, &notify_action_from_buffer);
	}
	ok(notify_action_from_buffer,
			"Notify action created from payload is non-null");

	ok(lttng_action_is_equal(notify_action, notify_action_from_buffer),
			"Serialized and de-serialized notify action are equal");

	lttng_rate_policy_destroy(default_policy);
	lttng_rate_policy_destroy(policy);
	lttng_action_destroy(notify_action);
	lttng_action_destroy(notify_action_from_buffer);
	lttng_payload_reset(&payload);
}

static void test_action_rotate_session(void)
{
	int ret;
	enum lttng_action_status status;
	struct lttng_action *rotate_session_action = NULL,
			    *rotate_session_action_from_buffer = NULL;
	struct lttng_rate_policy *policy = NULL, *default_policy;
	struct lttng_payload payload;
	const char *session_name = "my_session_name";
	const char *get_session_name;

	lttng_payload_init(&payload);

	/* To set. */
	policy = lttng_rate_policy_every_n_create(100);
	/* For comparison. */
	default_policy = lttng_rate_policy_every_n_create(1);

	assert(policy && default_policy);

	rotate_session_action = lttng_action_rotate_session_create();
	ok(rotate_session_action, "Create rotate_session action");
	ok(lttng_action_get_type(rotate_session_action) ==
					LTTNG_ACTION_TYPE_ROTATE_SESSION,
			"Action has type LTTNG_ACTION_TYPE_ROTATE_SESSION");

	/* Session name setter. */
	status = lttng_action_rotate_session_set_session_name(NULL, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,NULL) expect invalid");
	status = lttng_action_rotate_session_set_session_name(
			rotate_session_action, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (object,NULL) expect invalid");
	status = lttng_action_rotate_session_set_session_name(
			NULL, session_name);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,object) expect invalid");

	/* Set the session name */
	status = lttng_action_rotate_session_set_session_name(
			rotate_session_action, session_name);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");

	status = lttng_action_rotate_session_get_session_name(
			rotate_session_action, &get_session_name);
	ok(status == LTTNG_ACTION_STATUS_OK &&
					!strcmp(session_name, get_session_name),
			"Get session name, expected `%s` got `%s`",
			session_name, get_session_name);

	/* Validate the default policy for a rotate_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_rotate_session_get_rate_policy(
				rotate_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								default_policy,
								cur_policy),
				"Default policy is every n=1");
	}

	/* Set a custom policy. */
	status = lttng_action_rotate_session_set_rate_policy(
			rotate_session_action, policy);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");

	/* Validate the custom policy for a rotate_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_rotate_session_get_rate_policy(
				rotate_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								policy,
								cur_policy),
				"rotate_session action policy get");
	}

	/* Ser/des tests. */
	ret = lttng_action_serialize(rotate_session_action, &payload);
	ok(ret == 0, "Action rotate_session serialized");

	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);
		(void) lttng_action_create_from_payload(
				&view, &rotate_session_action_from_buffer);
	}
	ok(rotate_session_action_from_buffer,
			"rotate_session action created from payload is non-null");

	ok(lttng_action_is_equal(rotate_session_action,
			   rotate_session_action_from_buffer),
			"Serialized and de-serialized rotate_session action are equal");

	lttng_rate_policy_destroy(default_policy);
	lttng_rate_policy_destroy(policy);
	lttng_action_destroy(rotate_session_action);
	lttng_action_destroy(rotate_session_action_from_buffer);
	lttng_payload_reset(&payload);
}

static void test_action_start_session(void)
{
	int ret;
	enum lttng_action_status status;
	struct lttng_action *start_session_action = NULL,
			    *start_session_action_from_buffer = NULL;
	struct lttng_rate_policy *policy = NULL, *default_policy;
	struct lttng_payload payload;
	const char *session_name = "my_session_name";
	const char *get_session_name;

	lttng_payload_init(&payload);

	/* To set. */
	policy = lttng_rate_policy_every_n_create(100);
	/* For comparison. */
	default_policy = lttng_rate_policy_every_n_create(1);

	assert(policy && default_policy);

	start_session_action = lttng_action_start_session_create();
	ok(start_session_action, "Create start_session action");
	ok(lttng_action_get_type(start_session_action) ==
					LTTNG_ACTION_TYPE_START_SESSION,
			"Action has type LTTNG_ACTION_TYPE_START_SESSION");

	/* Session name setter. */
	status = lttng_action_start_session_set_session_name(NULL, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,NULL) expect invalid");
	status = lttng_action_start_session_set_session_name(
			start_session_action, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (object,NULL) expect invalid");
	status = lttng_action_start_session_set_session_name(
			NULL, session_name);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,object) expect invalid");

	/* Set the session name */
	status = lttng_action_start_session_set_session_name(
			start_session_action, session_name);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");

	status = lttng_action_start_session_get_session_name(
			start_session_action, &get_session_name);
	ok(status == LTTNG_ACTION_STATUS_OK &&
					!strcmp(session_name, get_session_name),
			"Get session name, expected `%s` got `%s`",
			session_name, get_session_name);

	/* Validate the default policy for a start_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_start_session_get_rate_policy(
				start_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								default_policy,
								cur_policy),
				"Default policy is every n=1");
	}

	/* Set a custom policy. */
	status = lttng_action_start_session_set_rate_policy(
			start_session_action, policy);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");

	/* Validate the custom policy for a start_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_start_session_get_rate_policy(
				start_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								policy,
								cur_policy),
				"start_session action policy get");
	}

	/* Ser/des tests. */
	ret = lttng_action_serialize(start_session_action, &payload);
	ok(ret == 0, "Action start_session serialized");

	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);
		(void) lttng_action_create_from_payload(
				&view, &start_session_action_from_buffer);
	}
	ok(start_session_action_from_buffer,
			"start_session action created from payload is non-null");

	ok(lttng_action_is_equal(start_session_action,
			   start_session_action_from_buffer),
			"Serialized and de-serialized start_session action are equal");

	lttng_rate_policy_destroy(default_policy);
	lttng_rate_policy_destroy(policy);
	lttng_action_destroy(start_session_action);
	lttng_action_destroy(start_session_action_from_buffer);
	lttng_payload_reset(&payload);
}

static void test_action_stop_session(void)
{
	int ret;
	enum lttng_action_status status;
	struct lttng_action *stop_session_action = NULL,
			    *stop_session_action_from_buffer = NULL;
	struct lttng_rate_policy *policy = NULL, *default_policy;
	struct lttng_payload payload;
	const char *session_name = "my_session_name";
	const char *get_session_name;

	lttng_payload_init(&payload);

	/* To set. */
	policy = lttng_rate_policy_every_n_create(100);
	/* For comparison. */
	default_policy = lttng_rate_policy_every_n_create(1);

	assert(policy && default_policy);

	stop_session_action = lttng_action_stop_session_create();
	ok(stop_session_action, "Create stop_session action");
	ok(lttng_action_get_type(stop_session_action) ==
					LTTNG_ACTION_TYPE_STOP_SESSION,
			"Action has type LTTNG_ACTION_TYPE_STOP_SESSION");

	/* Session name setter. */
	status = lttng_action_stop_session_set_session_name(NULL, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,NULL) expect invalid");
	status = lttng_action_stop_session_set_session_name(
			stop_session_action, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (object,NULL) expect invalid");
	status = lttng_action_stop_session_set_session_name(NULL, session_name);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,object) expect invalid");

	/* Set the session name */
	status = lttng_action_stop_session_set_session_name(
			stop_session_action, session_name);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");

	status = lttng_action_stop_session_get_session_name(
			stop_session_action, &get_session_name);
	ok(status == LTTNG_ACTION_STATUS_OK &&
					!strcmp(session_name, get_session_name),
			"Get session name, expected `%s` got `%s`",
			session_name, get_session_name);

	/* Validate the default policy for a stop_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_stop_session_get_rate_policy(
				stop_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								default_policy,
								cur_policy),
				"Default policy is every n=1");
	}

	/* Set a custom policy. */
	status = lttng_action_stop_session_set_rate_policy(
			stop_session_action, policy);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");

	/* Validate the custom policy for a stop_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_stop_session_get_rate_policy(
				stop_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								policy,
								cur_policy),
				"stop_session action policy get");
	}

	/* Ser/des tests. */
	ret = lttng_action_serialize(stop_session_action, &payload);
	ok(ret == 0, "Action stop_session serialized");

	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);
		(void) lttng_action_create_from_payload(
				&view, &stop_session_action_from_buffer);
	}
	ok(stop_session_action_from_buffer,
			"stop_session action created from payload is non-null");

	ok(lttng_action_is_equal(stop_session_action,
			   stop_session_action_from_buffer),
			"Serialized and de-serialized stop_session action are equal");

	lttng_rate_policy_destroy(default_policy);
	lttng_rate_policy_destroy(policy);
	lttng_action_destroy(stop_session_action);
	lttng_action_destroy(stop_session_action_from_buffer);
	lttng_payload_reset(&payload);
}

static void test_action_snapshot_session(void)
{
	int ret;
	enum lttng_action_status status;
	struct lttng_action *snapshot_session_action = NULL,
			    *snapshot_session_action_from_buffer = NULL;
	struct lttng_rate_policy *policy = NULL, *default_policy;
	struct lttng_payload payload;
	const char *session_name = "my_session_name";
	const char *get_session_name;

	lttng_payload_init(&payload);

	/* To set. */
	policy = lttng_rate_policy_every_n_create(100);
	/* For comparison. */
	default_policy = lttng_rate_policy_every_n_create(1);

	assert(policy && default_policy);

	snapshot_session_action = lttng_action_snapshot_session_create();
	ok(snapshot_session_action, "Create snapshot_session action");
	ok(lttng_action_get_type(snapshot_session_action) ==
					LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
			"Action has type LTTNG_ACTION_TYPE_SNAPSHOT_SESSION");

	/* Session name setter. */
	status = lttng_action_snapshot_session_set_session_name(NULL, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,NULL) expect invalid");
	status = lttng_action_snapshot_session_set_session_name(
			snapshot_session_action, NULL);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (object,NULL) expect invalid");
	status = lttng_action_snapshot_session_set_session_name(
			NULL, session_name);
	ok(status == LTTNG_ACTION_STATUS_INVALID,
			"Set session name (NULL,object) expect invalid");

	/* Set the session name */
	status = lttng_action_snapshot_session_set_session_name(
			snapshot_session_action, session_name);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");

	status = lttng_action_snapshot_session_get_session_name(
			snapshot_session_action, &get_session_name);
	ok(status == LTTNG_ACTION_STATUS_OK &&
					!strcmp(session_name, get_session_name),
			"Get session name, expected `%s` got `%s`",
			session_name, get_session_name);

	/* Validate the default policy for a snapshot_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_snapshot_session_get_rate_policy(
				snapshot_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								default_policy,
								cur_policy),
				"Default policy is every n=1");
	}

	/* Set a custom policy. */
	status = lttng_action_snapshot_session_set_rate_policy(
			snapshot_session_action, policy);
	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");

	/* Validate the custom policy for a snapshot_session action. */
	{
		const struct lttng_rate_policy *cur_policy = NULL;
		status = lttng_action_snapshot_session_get_rate_policy(
				snapshot_session_action, &cur_policy);
		ok(status == LTTNG_ACTION_STATUS_OK &&
						lttng_rate_policy_is_equal(
								policy,
								cur_policy),
				"snapshot_session action policy get");
	}

	/* Ser/des tests. */
	ret = lttng_action_serialize(snapshot_session_action, &payload);
	ok(ret == 0, "Action snapshot_session serialized");

	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);
		(void) lttng_action_create_from_payload(
				&view, &snapshot_session_action_from_buffer);
	}
	ok(snapshot_session_action_from_buffer,
			"snapshot_session action created from payload is non-null");

	ok(lttng_action_is_equal(snapshot_session_action,
			   snapshot_session_action_from_buffer),
			"Serialized and de-serialized snapshot_session action are equal");

	lttng_rate_policy_destroy(default_policy);
	lttng_rate_policy_destroy(policy);
	lttng_action_destroy(snapshot_session_action);
	lttng_action_destroy(snapshot_session_action_from_buffer);
	lttng_payload_reset(&payload);
}

int main(int argc, const char *argv[])
{
	plan_tests(NUM_TESTS);
	test_action_notify();
	test_action_rotate_session();
	test_action_start_session();
	test_action_stop_session();
	test_action_snapshot_session();
	return exit_status();
}
Commit	Line	Data
9cff59ec JR	1	/*
	2	* test_action.c
	3	*
	4	* Unit tests for the notification API.
	5	*
	6	* Copyright (C) 2017 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
	7	*
	8	* SPDX-License-Identifier: MIT
	9	*
	10	*/
	11
	12	#include <assert.h>
	13	#include <inttypes.h>
	14	#include <stdio.h>
	15	#include <string.h>
	16	#include <unistd.h>
	17
	18	#include <tap/tap.h>
	19
	20	#include <common/payload-view.h>
	21	#include <common/payload.h>
	22	#include <lttng/action/action-internal.h>
	23	#include <lttng/action/action.h>
9cff59ec	24	#include <lttng/action/notify.h>
7f4d5b07 JR	25	#include <lttng/action/rate-policy-internal.h>
7f4d5b07 JR	26	#include <lttng/action/rate-policy.h>
ce1c2b5d	27	#include <lttng/action/rotate-session.h>
5b2c0a3e	28	#include <lttng/action/snapshot-session.h>
ea453cf4	29	#include <lttng/action/start-session.h>
3474dcb1	30	#include <lttng/action/stop-session.h>
9cff59ec JR	31
	32	/* For error.h */
	33	int lttng_opt_quiet = 1;
	34	int lttng_opt_verbose;
	35	int lttng_opt_mi;
	36
5b2c0a3e	37	#define NUM_TESTS 60
9cff59ec JR	38
	39	static void test_action_notify(void)
	40	{
193cc911 JR	41	int ret;
	42	enum lttng_action_status status;
	43	struct lttng_action *notify_action = NULL,
	44	*notify_action_from_buffer = NULL;
7f4d5b07	45	struct lttng_rate_policy policy = NULL, default_policy;
193cc911 JR	46	struct lttng_payload payload;
	47
	48	lttng_payload_init(&payload);
	49
	50	/* To set. */
7f4d5b07	51	policy = lttng_rate_policy_every_n_create(100);
193cc911	52	/* For comparison. */
7f4d5b07	53	default_policy = lttng_rate_policy_every_n_create(1);
193cc911 JR	54
193cc911 JR	55	assert(policy && default_policy);
9cff59ec JR	56
	57	notify_action = lttng_action_notify_create();
	58	ok(notify_action, "Create notify action");
	59	ok(lttng_action_get_type(notify_action) == LTTNG_ACTION_TYPE_NOTIFY,
	60	"Action has type LTTNG_ACTION_TYPE_NOTIFY");
193cc911 JR	61
	62	/* Validate the default policy for a notify action. */
	63	{
7f4d5b07 JR	64	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	65	status = lttng_action_notify_get_rate_policy(
193cc911 JR	66	notify_action, &cur_policy);
193cc911 JR	67	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	68	lttng_rate_policy_is_equal(
193cc911 JR	69	default_policy,
	70	cur_policy),
	71	"Default policy is every n=1");
	72	}
	73
	74	/* Set a custom policy. */
7f4d5b07 JR	75	status = lttng_action_notify_set_rate_policy(notify_action, policy);
7f4d5b07 JR	76	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
193cc911 JR	77
	78	/* Validate the custom policy for a notify action. */
	79	{
7f4d5b07 JR	80	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	81	status = lttng_action_notify_get_rate_policy(
193cc911 JR	82	notify_action, &cur_policy);
193cc911 JR	83	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	84	lttng_rate_policy_is_equal(
193cc911 JR	85	policy,
	86	cur_policy),
	87	"Notify action policy get");
	88	}
	89
	90	ret = lttng_action_serialize(notify_action, &payload);
	91	ok(ret == 0, "Action notify serialized");
	92
	93	{
	94	struct lttng_payload_view view =
	95	lttng_payload_view_from_payload(
	96	&payload, 0, -1);
	97	(void) lttng_action_create_from_payload(
	98	&view, &notify_action_from_buffer);
	99	}
	100	ok(notify_action_from_buffer,
	101	"Notify action created from payload is non-null");
	102
	103	ok(lttng_action_is_equal(notify_action, notify_action_from_buffer),
	104	"Serialized and de-serialized notify action are equal");
	105
7f4d5b07 JR	106	lttng_rate_policy_destroy(default_policy);
7f4d5b07 JR	107	lttng_rate_policy_destroy(policy);
9cff59ec	108	lttng_action_destroy(notify_action);
193cc911 JR	109	lttng_action_destroy(notify_action_from_buffer);
193cc911 JR	110	lttng_payload_reset(&payload);
9cff59ec JR	111	}
9cff59ec JR	112
ce1c2b5d JR	113	static void test_action_rotate_session(void)
	114	{
	115	int ret;
	116	enum lttng_action_status status;
	117	struct lttng_action *rotate_session_action = NULL,
	118	*rotate_session_action_from_buffer = NULL;
7f4d5b07	119	struct lttng_rate_policy policy = NULL, default_policy;
ce1c2b5d JR	120	struct lttng_payload payload;
	121	const char *session_name = "my_session_name";
	122	const char *get_session_name;
	123
	124	lttng_payload_init(&payload);
	125
	126	/* To set. */
7f4d5b07	127	policy = lttng_rate_policy_every_n_create(100);
ce1c2b5d	128	/* For comparison. */
7f4d5b07	129	default_policy = lttng_rate_policy_every_n_create(1);
ce1c2b5d JR	130
	131	assert(policy && default_policy);
	132
	133	rotate_session_action = lttng_action_rotate_session_create();
	134	ok(rotate_session_action, "Create rotate_session action");
	135	ok(lttng_action_get_type(rotate_session_action) ==
	136	LTTNG_ACTION_TYPE_ROTATE_SESSION,
	137	"Action has type LTTNG_ACTION_TYPE_ROTATE_SESSION");
	138
	139	/* Session name setter. */
	140	status = lttng_action_rotate_session_set_session_name(NULL, NULL);
	141	ok(status == LTTNG_ACTION_STATUS_INVALID,
	142	"Set session name (NULL,NULL) expect invalid");
	143	status = lttng_action_rotate_session_set_session_name(
	144	rotate_session_action, NULL);
	145	ok(status == LTTNG_ACTION_STATUS_INVALID,
	146	"Set session name (object,NULL) expect invalid");
	147	status = lttng_action_rotate_session_set_session_name(
	148	NULL, session_name);
	149	ok(status == LTTNG_ACTION_STATUS_INVALID,
	150	"Set session name (NULL,object) expect invalid");
	151
	152	/* Set the session name */
	153	status = lttng_action_rotate_session_set_session_name(
	154	rotate_session_action, session_name);
	155	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
	156
	157	status = lttng_action_rotate_session_get_session_name(
	158	rotate_session_action, &get_session_name);
	159	ok(status == LTTNG_ACTION_STATUS_OK &&
	160	!strcmp(session_name, get_session_name),
	161	"Get session name, expected `%s` got `%s`",
	162	session_name, get_session_name);
	163
	164	/* Validate the default policy for a rotate_session action. */
	165	{
7f4d5b07 JR	166	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	167	status = lttng_action_rotate_session_get_rate_policy(
ce1c2b5d JR	168	rotate_session_action, &cur_policy);
ce1c2b5d JR	169	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	170	lttng_rate_policy_is_equal(
ce1c2b5d JR	171	default_policy,
	172	cur_policy),
	173	"Default policy is every n=1");
	174	}
	175
	176	/* Set a custom policy. */
7f4d5b07	177	status = lttng_action_rotate_session_set_rate_policy(
ce1c2b5d	178	rotate_session_action, policy);
7f4d5b07	179	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
ce1c2b5d JR	180
	181	/* Validate the custom policy for a rotate_session action. */
	182	{
7f4d5b07 JR	183	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	184	status = lttng_action_rotate_session_get_rate_policy(
ce1c2b5d JR	185	rotate_session_action, &cur_policy);
ce1c2b5d JR	186	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	187	lttng_rate_policy_is_equal(
ce1c2b5d JR	188	policy,
	189	cur_policy),
	190	"rotate_session action policy get");
	191	}
	192
	193	/* Ser/des tests. */
	194	ret = lttng_action_serialize(rotate_session_action, &payload);
	195	ok(ret == 0, "Action rotate_session serialized");
	196
	197	{
	198	struct lttng_payload_view view =
	199	lttng_payload_view_from_payload(
	200	&payload, 0, -1);
	201	(void) lttng_action_create_from_payload(
	202	&view, &rotate_session_action_from_buffer);
	203	}
	204	ok(rotate_session_action_from_buffer,
	205	"rotate_session action created from payload is non-null");
	206
	207	ok(lttng_action_is_equal(rotate_session_action,
	208	rotate_session_action_from_buffer),
	209	"Serialized and de-serialized rotate_session action are equal");
	210
7f4d5b07 JR	211	lttng_rate_policy_destroy(default_policy);
7f4d5b07 JR	212	lttng_rate_policy_destroy(policy);
ce1c2b5d JR	213	lttng_action_destroy(rotate_session_action);
	214	lttng_action_destroy(rotate_session_action_from_buffer);
	215	lttng_payload_reset(&payload);
	216	}
	217
ea453cf4 JR	218	static void test_action_start_session(void)
	219	{
	220	int ret;
	221	enum lttng_action_status status;
	222	struct lttng_action *start_session_action = NULL,
	223	*start_session_action_from_buffer = NULL;
7f4d5b07	224	struct lttng_rate_policy policy = NULL, default_policy;
ea453cf4 JR	225	struct lttng_payload payload;
	226	const char *session_name = "my_session_name";
	227	const char *get_session_name;
	228
	229	lttng_payload_init(&payload);
	230
	231	/* To set. */
7f4d5b07	232	policy = lttng_rate_policy_every_n_create(100);
ea453cf4	233	/* For comparison. */
7f4d5b07	234	default_policy = lttng_rate_policy_every_n_create(1);
ea453cf4 JR	235
	236	assert(policy && default_policy);
	237
	238	start_session_action = lttng_action_start_session_create();
	239	ok(start_session_action, "Create start_session action");
	240	ok(lttng_action_get_type(start_session_action) ==
	241	LTTNG_ACTION_TYPE_START_SESSION,
	242	"Action has type LTTNG_ACTION_TYPE_START_SESSION");
	243
	244	/* Session name setter. */
	245	status = lttng_action_start_session_set_session_name(NULL, NULL);
	246	ok(status == LTTNG_ACTION_STATUS_INVALID,
	247	"Set session name (NULL,NULL) expect invalid");
	248	status = lttng_action_start_session_set_session_name(
	249	start_session_action, NULL);
	250	ok(status == LTTNG_ACTION_STATUS_INVALID,
	251	"Set session name (object,NULL) expect invalid");
	252	status = lttng_action_start_session_set_session_name(
	253	NULL, session_name);
	254	ok(status == LTTNG_ACTION_STATUS_INVALID,
	255	"Set session name (NULL,object) expect invalid");
	256
	257	/* Set the session name */
	258	status = lttng_action_start_session_set_session_name(
	259	start_session_action, session_name);
	260	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
	261
	262	status = lttng_action_start_session_get_session_name(
	263	start_session_action, &get_session_name);
	264	ok(status == LTTNG_ACTION_STATUS_OK &&
	265	!strcmp(session_name, get_session_name),
	266	"Get session name, expected `%s` got `%s`",
	267	session_name, get_session_name);
	268
	269	/* Validate the default policy for a start_session action. */
	270	{
7f4d5b07 JR	271	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	272	status = lttng_action_start_session_get_rate_policy(
ea453cf4 JR	273	start_session_action, &cur_policy);
ea453cf4 JR	274	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	275	lttng_rate_policy_is_equal(
ea453cf4 JR	276	default_policy,
	277	cur_policy),
	278	"Default policy is every n=1");
	279	}
	280
	281	/* Set a custom policy. */
7f4d5b07	282	status = lttng_action_start_session_set_rate_policy(
ea453cf4	283	start_session_action, policy);
7f4d5b07	284	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
ea453cf4 JR	285
	286	/* Validate the custom policy for a start_session action. */
	287	{
7f4d5b07 JR	288	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	289	status = lttng_action_start_session_get_rate_policy(
ea453cf4 JR	290	start_session_action, &cur_policy);
ea453cf4 JR	291	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	292	lttng_rate_policy_is_equal(
ea453cf4 JR	293	policy,
	294	cur_policy),
	295	"start_session action policy get");
	296	}
	297
	298	/* Ser/des tests. */
	299	ret = lttng_action_serialize(start_session_action, &payload);
	300	ok(ret == 0, "Action start_session serialized");
	301
	302	{
	303	struct lttng_payload_view view =
	304	lttng_payload_view_from_payload(
	305	&payload, 0, -1);
	306	(void) lttng_action_create_from_payload(
	307	&view, &start_session_action_from_buffer);
	308	}
	309	ok(start_session_action_from_buffer,
	310	"start_session action created from payload is non-null");
	311
	312	ok(lttng_action_is_equal(start_session_action,
	313	start_session_action_from_buffer),
	314	"Serialized and de-serialized start_session action are equal");
	315
7f4d5b07 JR	316	lttng_rate_policy_destroy(default_policy);
7f4d5b07 JR	317	lttng_rate_policy_destroy(policy);
ea453cf4 JR	318	lttng_action_destroy(start_session_action);
	319	lttng_action_destroy(start_session_action_from_buffer);
	320	lttng_payload_reset(&payload);
	321	}
	322
3474dcb1 JR	323	static void test_action_stop_session(void)
	324	{
	325	int ret;
	326	enum lttng_action_status status;
	327	struct lttng_action *stop_session_action = NULL,
	328	*stop_session_action_from_buffer = NULL;
7f4d5b07	329	struct lttng_rate_policy policy = NULL, default_policy;
3474dcb1 JR	330	struct lttng_payload payload;
	331	const char *session_name = "my_session_name";
	332	const char *get_session_name;
	333
	334	lttng_payload_init(&payload);
	335
	336	/* To set. */
7f4d5b07	337	policy = lttng_rate_policy_every_n_create(100);
3474dcb1	338	/* For comparison. */
7f4d5b07	339	default_policy = lttng_rate_policy_every_n_create(1);
3474dcb1 JR	340
	341	assert(policy && default_policy);
	342
	343	stop_session_action = lttng_action_stop_session_create();
	344	ok(stop_session_action, "Create stop_session action");
	345	ok(lttng_action_get_type(stop_session_action) ==
	346	LTTNG_ACTION_TYPE_STOP_SESSION,
	347	"Action has type LTTNG_ACTION_TYPE_STOP_SESSION");
	348
	349	/* Session name setter. */
	350	status = lttng_action_stop_session_set_session_name(NULL, NULL);
	351	ok(status == LTTNG_ACTION_STATUS_INVALID,
	352	"Set session name (NULL,NULL) expect invalid");
	353	status = lttng_action_stop_session_set_session_name(
	354	stop_session_action, NULL);
	355	ok(status == LTTNG_ACTION_STATUS_INVALID,
	356	"Set session name (object,NULL) expect invalid");
	357	status = lttng_action_stop_session_set_session_name(NULL, session_name);
	358	ok(status == LTTNG_ACTION_STATUS_INVALID,
	359	"Set session name (NULL,object) expect invalid");
	360
	361	/* Set the session name */
	362	status = lttng_action_stop_session_set_session_name(
	363	stop_session_action, session_name);
	364	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
	365
	366	status = lttng_action_stop_session_get_session_name(
	367	stop_session_action, &get_session_name);
	368	ok(status == LTTNG_ACTION_STATUS_OK &&
	369	!strcmp(session_name, get_session_name),
	370	"Get session name, expected `%s` got `%s`",
	371	session_name, get_session_name);
	372
	373	/* Validate the default policy for a stop_session action. */
	374	{
7f4d5b07 JR	375	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	376	status = lttng_action_stop_session_get_rate_policy(
3474dcb1 JR	377	stop_session_action, &cur_policy);
3474dcb1 JR	378	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	379	lttng_rate_policy_is_equal(
3474dcb1 JR	380	default_policy,
	381	cur_policy),
	382	"Default policy is every n=1");
	383	}
	384
	385	/* Set a custom policy. */
7f4d5b07	386	status = lttng_action_stop_session_set_rate_policy(
3474dcb1	387	stop_session_action, policy);
7f4d5b07	388	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
3474dcb1 JR	389
	390	/* Validate the custom policy for a stop_session action. */
	391	{
7f4d5b07 JR	392	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	393	status = lttng_action_stop_session_get_rate_policy(
3474dcb1 JR	394	stop_session_action, &cur_policy);
3474dcb1 JR	395	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	396	lttng_rate_policy_is_equal(
3474dcb1 JR	397	policy,
	398	cur_policy),
	399	"stop_session action policy get");
	400	}
	401
	402	/* Ser/des tests. */
	403	ret = lttng_action_serialize(stop_session_action, &payload);
	404	ok(ret == 0, "Action stop_session serialized");
	405
	406	{
	407	struct lttng_payload_view view =
	408	lttng_payload_view_from_payload(
	409	&payload, 0, -1);
	410	(void) lttng_action_create_from_payload(
	411	&view, &stop_session_action_from_buffer);
	412	}
	413	ok(stop_session_action_from_buffer,
	414	"stop_session action created from payload is non-null");
	415
	416	ok(lttng_action_is_equal(stop_session_action,
	417	stop_session_action_from_buffer),
	418	"Serialized and de-serialized stop_session action are equal");
	419
7f4d5b07 JR	420	lttng_rate_policy_destroy(default_policy);
7f4d5b07 JR	421	lttng_rate_policy_destroy(policy);
3474dcb1 JR	422	lttng_action_destroy(stop_session_action);
	423	lttng_action_destroy(stop_session_action_from_buffer);
	424	lttng_payload_reset(&payload);
	425	}
	426
5b2c0a3e JR	427	static void test_action_snapshot_session(void)
	428	{
	429	int ret;
	430	enum lttng_action_status status;
	431	struct lttng_action *snapshot_session_action = NULL,
	432	*snapshot_session_action_from_buffer = NULL;
7f4d5b07	433	struct lttng_rate_policy policy = NULL, default_policy;
5b2c0a3e JR	434	struct lttng_payload payload;
	435	const char *session_name = "my_session_name";
	436	const char *get_session_name;
	437
	438	lttng_payload_init(&payload);
	439
	440	/* To set. */
7f4d5b07	441	policy = lttng_rate_policy_every_n_create(100);
5b2c0a3e	442	/* For comparison. */
7f4d5b07	443	default_policy = lttng_rate_policy_every_n_create(1);
5b2c0a3e JR	444
	445	assert(policy && default_policy);
	446
	447	snapshot_session_action = lttng_action_snapshot_session_create();
	448	ok(snapshot_session_action, "Create snapshot_session action");
	449	ok(lttng_action_get_type(snapshot_session_action) ==
	450	LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
	451	"Action has type LTTNG_ACTION_TYPE_SNAPSHOT_SESSION");
	452
	453	/* Session name setter. */
	454	status = lttng_action_snapshot_session_set_session_name(NULL, NULL);
	455	ok(status == LTTNG_ACTION_STATUS_INVALID,
	456	"Set session name (NULL,NULL) expect invalid");
	457	status = lttng_action_snapshot_session_set_session_name(
	458	snapshot_session_action, NULL);
	459	ok(status == LTTNG_ACTION_STATUS_INVALID,
	460	"Set session name (object,NULL) expect invalid");
	461	status = lttng_action_snapshot_session_set_session_name(
	462	NULL, session_name);
	463	ok(status == LTTNG_ACTION_STATUS_INVALID,
	464	"Set session name (NULL,object) expect invalid");
	465
	466	/* Set the session name */
	467	status = lttng_action_snapshot_session_set_session_name(
	468	snapshot_session_action, session_name);
	469	ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
	470
	471	status = lttng_action_snapshot_session_get_session_name(
	472	snapshot_session_action, &get_session_name);
	473	ok(status == LTTNG_ACTION_STATUS_OK &&
	474	!strcmp(session_name, get_session_name),
	475	"Get session name, expected `%s` got `%s`",
	476	session_name, get_session_name);
	477
	478	/* Validate the default policy for a snapshot_session action. */
	479	{
7f4d5b07 JR	480	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	481	status = lttng_action_snapshot_session_get_rate_policy(
5b2c0a3e JR	482	snapshot_session_action, &cur_policy);
5b2c0a3e JR	483	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	484	lttng_rate_policy_is_equal(
5b2c0a3e JR	485	default_policy,
	486	cur_policy),
	487	"Default policy is every n=1");
	488	}
	489
	490	/* Set a custom policy. */
7f4d5b07	491	status = lttng_action_snapshot_session_set_rate_policy(
5b2c0a3e	492	snapshot_session_action, policy);
7f4d5b07	493	ok(status == LTTNG_ACTION_STATUS_OK, "Set rate policy");
5b2c0a3e JR	494
	495	/* Validate the custom policy for a snapshot_session action. */
	496	{
7f4d5b07 JR	497	const struct lttng_rate_policy *cur_policy = NULL;
7f4d5b07 JR	498	status = lttng_action_snapshot_session_get_rate_policy(
5b2c0a3e JR	499	snapshot_session_action, &cur_policy);
5b2c0a3e JR	500	ok(status == LTTNG_ACTION_STATUS_OK &&
7f4d5b07	501	lttng_rate_policy_is_equal(
5b2c0a3e JR	502	policy,
	503	cur_policy),
	504	"snapshot_session action policy get");
	505	}
	506
	507	/* Ser/des tests. */
	508	ret = lttng_action_serialize(snapshot_session_action, &payload);
	509	ok(ret == 0, "Action snapshot_session serialized");
	510
	511	{
	512	struct lttng_payload_view view =
	513	lttng_payload_view_from_payload(
	514	&payload, 0, -1);
	515	(void) lttng_action_create_from_payload(
	516	&view, &snapshot_session_action_from_buffer);
	517	}
	518	ok(snapshot_session_action_from_buffer,
	519	"snapshot_session action created from payload is non-null");
	520
	521	ok(lttng_action_is_equal(snapshot_session_action,
	522	snapshot_session_action_from_buffer),
	523	"Serialized and de-serialized snapshot_session action are equal");
	524
7f4d5b07 JR	525	lttng_rate_policy_destroy(default_policy);
7f4d5b07 JR	526	lttng_rate_policy_destroy(policy);
5b2c0a3e JR	527	lttng_action_destroy(snapshot_session_action);
	528	lttng_action_destroy(snapshot_session_action_from_buffer);
	529	lttng_payload_reset(&payload);
	530	}
	531
9cff59ec JR	532	int main(int argc, const char *argv[])
	533	{
	534	plan_tests(NUM_TESTS);
	535	test_action_notify();
ce1c2b5d	536	test_action_rotate_session();
ea453cf4	537	test_action_start_session();
3474dcb1	538	test_action_stop_session();
5b2c0a3e	539	test_action_snapshot_session();
9cff59ec JR	540	return exit_status();
9cff59ec JR	541	}