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

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

#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);

	LTTNG_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);

	LTTNG_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);

	LTTNG_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);

	LTTNG_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);

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