[lttng-tools.git] / tests / regression / tools / rotation / schedule_api.c

/*
 * schedule_api.c
 *
 * Unit tests for the session rotation schedule API
 *
 * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: MIT
 *
 */

#include <stddef.h>
#include <stdbool.h>
#include <tap/tap.h>

#include <lttng/lttng.h>

#define NUM_TESTS 26

#define SIZE_THRESHOLD_BYTES 1024
#define PERIODIC_TIME_US 1000000

const char *session_name;

static bool schedules_equal(const struct lttng_rotation_schedule *a,
		const struct lttng_rotation_schedule *b)
{
	bool equal = false;
	enum lttng_rotation_schedule_type a_type, b_type;
	uint64_t a_value, b_value;
	enum lttng_rotation_status status;

	a_type = lttng_rotation_schedule_get_type(a);
	b_type = lttng_rotation_schedule_get_type(b);
	if (a_type != b_type) {
		diag("Schedules are not of the same type (%i != %i)",
				a_type, b_type);
		goto end;
	}

	switch (a_type) {
	case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
	{
		status = lttng_rotation_schedule_size_threshold_get_threshold(a,
				&a_value);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			diag("Failed to retrieve size threshold of schedule 'a'");
			goto end;
		}
		status = lttng_rotation_schedule_size_threshold_get_threshold(b,
				&b_value);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			diag("Failed to retrieve size threshold of schedule 'b'");
			goto end;
		}
		break;
	}
	case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
	{
		status = lttng_rotation_schedule_periodic_get_period(a,
				&a_value);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			diag("Failed to retrieve period of schedule 'a'");
			goto end;
		}
		status = lttng_rotation_schedule_periodic_get_period(b,
				&b_value);
		if (status != LTTNG_ROTATION_STATUS_OK) {
			diag("Failed to retrieve period of schedule 'b'");
			goto end;
		}
		break;
	}
	default:
		diag("Unexpected schedule type: %i", a_type);
		goto end;
	}

	equal = a_value == b_value;
	if (!equal) {
		diag("Schedules have different values");
	}
end:
	return equal;
}

static void test_add_null_session(void)
{
	enum lttng_rotation_status status;
	struct lttng_rotation_schedule *size_schedule = NULL;

	size_schedule = lttng_rotation_schedule_size_threshold_create();

	status = lttng_session_add_rotation_schedule(NULL, size_schedule);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"NULL session name rejected by lttng_session_add_rotation_schedule()");
	lttng_rotation_schedule_destroy(size_schedule);
}

static void test_add_null_schedule(void)
{
	enum lttng_rotation_status status;

	status = lttng_session_add_rotation_schedule(session_name, NULL);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"NULL schedule rejected by lttng_session_add_rotation_schedule()");
}

static void test_add_uninitialized_schedule(void)
{
	enum lttng_rotation_status status;
	struct lttng_rotation_schedule *size_schedule = NULL,
			*periodic_schedule = NULL;

	size_schedule = lttng_rotation_schedule_size_threshold_create();
	ok(size_schedule, "Created a size threshold session rotation schedule");

	status = lttng_session_add_rotation_schedule(session_name,
			size_schedule);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"Uninitialized size schedule rejected by lttng_session_add_rotation_schedule()");

	periodic_schedule = lttng_rotation_schedule_periodic_create();
	ok(periodic_schedule, "Created a periodic session rotation schedule");

	status = lttng_session_add_rotation_schedule(session_name,
			periodic_schedule);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"Uninitialized periodic schedule rejected by lttng_session_add_rotation_schedule()");

	lttng_rotation_schedule_destroy(size_schedule);
	lttng_rotation_schedule_destroy(periodic_schedule);
}

static void test_remove_null_session(void)
{
	enum lttng_rotation_status status;
	struct lttng_rotation_schedule *size_schedule = NULL;

	size_schedule = lttng_rotation_schedule_size_threshold_create();

	status = lttng_session_remove_rotation_schedule(NULL, size_schedule);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"NULL session name rejected by lttng_session_remove_rotation_schedule()");
	lttng_rotation_schedule_destroy(size_schedule);
}

static void test_remove_null_schedule(void)
{
	enum lttng_rotation_status status;

	status = lttng_session_remove_rotation_schedule(session_name, NULL);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"NULL schedule rejected by lttng_session_remove_rotation_schedule()");
}

static void test_remove_uninitialized_schedule(void)
{
	enum lttng_rotation_status status;
	struct lttng_rotation_schedule *size_schedule = NULL,
			*periodic_schedule = NULL;

	size_schedule = lttng_rotation_schedule_size_threshold_create();
	status = lttng_session_remove_rotation_schedule(session_name,
			size_schedule);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"Uninitialized size schedule rejected by lttng_session_remove_rotation_schedule()");

	periodic_schedule = lttng_rotation_schedule_periodic_create();
	status = lttng_session_remove_rotation_schedule(session_name,
			periodic_schedule);
	ok(status == LTTNG_ROTATION_STATUS_INVALID,
			"Uninitialized periodic schedule rejected by lttng_session_remove_rotation_schedule()");

	lttng_rotation_schedule_destroy(size_schedule);
	lttng_rotation_schedule_destroy(periodic_schedule);
}

static void test_uninitialized_schedule_get(void)
{
	uint64_t value;
	enum lttng_rotation_status status;
	struct lttng_rotation_schedule *size_schedule = NULL,
			*periodic_schedule = NULL;

	size_schedule = lttng_rotation_schedule_size_threshold_create();
	periodic_schedule = lttng_rotation_schedule_periodic_create();

	status = lttng_rotation_schedule_size_threshold_get_threshold(
			size_schedule, &value);
	ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE,
			"Getter on size threshold rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default");
	status = lttng_rotation_schedule_periodic_get_period(periodic_schedule,
			&value);
	ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE,
			"Getter on periodic rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default");

	lttng_rotation_schedule_destroy(size_schedule);
	lttng_rotation_schedule_destroy(periodic_schedule);

}

static void test_add_list_remove_schedule(
		const struct lttng_rotation_schedule *original_schedule)
{
	int ret;
	unsigned int schedules_count = 0;
	enum lttng_rotation_status status;
	const struct lttng_rotation_schedule *list_schedule;
	struct lttng_rotation_schedules *list_schedules;

	status = lttng_session_add_rotation_schedule(session_name,
			original_schedule);
	ok(status == LTTNG_ROTATION_STATUS_OK,
			"Add a rotation schedule to session \'%s\'",
			session_name);

	ret = lttng_session_list_rotation_schedules(session_name,
			&list_schedules);
	ok(ret == LTTNG_OK && list_schedules,
			"List rotation schedules of session \'%s\'",
			session_name);

	status = lttng_rotation_schedules_get_count(list_schedules,
			&schedules_count);
	ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 1,
			"Listing returned 1 rotation schedule");

	list_schedule = lttng_rotation_schedules_get_at_index(list_schedules,
			0);
	ok(list_schedule,
			"Obtain the first schedule of a schedules list");

	ok(schedules_equal(original_schedule, list_schedule),
			"Schedule returned by the listing is equal to the reference schedule that was added");

	status = lttng_session_remove_rotation_schedule(session_name,
			list_schedule);
	ok(status == LTTNG_ROTATION_STATUS_OK,
			"Remove rotation schedule returned by the schedules listing");
	lttng_rotation_schedules_destroy(list_schedules);

	(void) lttng_session_list_rotation_schedules(session_name,
			&list_schedules);
	status = lttng_rotation_schedules_get_count(list_schedules,
			&schedules_count);
	ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 0,
			"Listing returned 0 rotation schedules after removal");

}

static void test_add_list_remove_size_schedule(void)
{
	struct lttng_rotation_schedule *size_schedule;

	diag("Add, list, and remove a size threshold rotation schedule");
	size_schedule = lttng_rotation_schedule_size_threshold_create();
	(void) lttng_rotation_schedule_size_threshold_set_threshold(
			size_schedule, SIZE_THRESHOLD_BYTES);
	test_add_list_remove_schedule(size_schedule);
	lttng_rotation_schedule_destroy(size_schedule);
}

static void test_add_list_remove_periodic_schedule(void)
{
	struct lttng_rotation_schedule *periodic_schedule;

	diag("Add, list, and remove a periodic rotation schedule");
	periodic_schedule = lttng_rotation_schedule_periodic_create();
	(void) lttng_rotation_schedule_periodic_set_period(
			periodic_schedule, PERIODIC_TIME_US);
	test_add_list_remove_schedule(periodic_schedule);
	lttng_rotation_schedule_destroy(periodic_schedule);
}

int main(int argc, char **argv)
{
	plan_tests(NUM_TESTS);

	if (argc < 2) {
		diag("Usage: schedule_api SESSION_NAME");
		goto end;
	}

	session_name = argv[1];

	diag("Argument validation");
	test_add_null_session();
	test_add_null_schedule();
	test_add_uninitialized_schedule();
	test_remove_null_session();
	test_remove_null_schedule();
	test_remove_uninitialized_schedule();
	test_uninitialized_schedule_get();

	test_add_list_remove_size_schedule();
	test_add_list_remove_periodic_schedule();
end:
	return exit_status();
}
Commit	Line	Data
ed9f1fb2 JG	1	/*
	2	* schedule_api.c
	3	*
	4	* Unit tests for the session rotation schedule API
	5	*
	6	* Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
	7	*
9d16b343	8	* SPDX-License-Identifier: MIT
ed9f1fb2	9	*
ed9f1fb2 JG	10	*/
	11
	12	#include <stddef.h>
	13	#include <stdbool.h>
	14	#include <tap/tap.h>
	15
	16	#include <lttng/lttng.h>
	17
	18	#define NUM_TESTS 26
	19
	20	#define SIZE_THRESHOLD_BYTES 1024
	21	#define PERIODIC_TIME_US 1000000
	22
	23	const char *session_name;
	24
1831ae68	25	static bool schedules_equal(const struct lttng_rotation_schedule *a,
ed9f1fb2 JG	26	const struct lttng_rotation_schedule *b)
	27	{
	28	bool equal = false;
	29	enum lttng_rotation_schedule_type a_type, b_type;
	30	uint64_t a_value, b_value;
	31	enum lttng_rotation_status status;
	32
	33	a_type = lttng_rotation_schedule_get_type(a);
	34	b_type = lttng_rotation_schedule_get_type(b);
	35	if (a_type != b_type) {
	36	diag("Schedules are not of the same type (%i != %i)",
	37	a_type, b_type);
	38	goto end;
	39	}
	40
	41	switch (a_type) {
	42	case LTTNG_ROTATION_SCHEDULE_TYPE_SIZE_THRESHOLD:
	43	{
	44	status = lttng_rotation_schedule_size_threshold_get_threshold(a,
	45	&a_value);
	46	if (status != LTTNG_ROTATION_STATUS_OK) {
	47	diag("Failed to retrieve size threshold of schedule 'a'");
	48	goto end;
	49	}
	50	status = lttng_rotation_schedule_size_threshold_get_threshold(b,
	51	&b_value);
	52	if (status != LTTNG_ROTATION_STATUS_OK) {
	53	diag("Failed to retrieve size threshold of schedule 'b'");
	54	goto end;
	55	}
	56	break;
	57	}
	58	case LTTNG_ROTATION_SCHEDULE_TYPE_PERIODIC:
	59	{
	60	status = lttng_rotation_schedule_periodic_get_period(a,
	61	&a_value);
	62	if (status != LTTNG_ROTATION_STATUS_OK) {
	63	diag("Failed to retrieve period of schedule 'a'");
	64	goto end;
	65	}
	66	status = lttng_rotation_schedule_periodic_get_period(b,
	67	&b_value);
	68	if (status != LTTNG_ROTATION_STATUS_OK) {
	69	diag("Failed to retrieve period of schedule 'b'");
	70	goto end;
	71	}
	72	break;
	73	}
	74	default:
	75	diag("Unexpected schedule type: %i", a_type);
	76	goto end;
	77	}
	78
	79	equal = a_value == b_value;
	80	if (!equal) {
	81	diag("Schedules have different values");
	82	}
	83	end:
	84	return equal;
	85	}
	86
1831ae68	87	static void test_add_null_session(void)
ed9f1fb2 JG	88	{
	89	enum lttng_rotation_status status;
	90	struct lttng_rotation_schedule *size_schedule = NULL;
	91
	92	size_schedule = lttng_rotation_schedule_size_threshold_create();
	93
	94	status = lttng_session_add_rotation_schedule(NULL, size_schedule);
	95	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	96	"NULL session name rejected by lttng_session_add_rotation_schedule()");
4edd268b	97	lttng_rotation_schedule_destroy(size_schedule);
ed9f1fb2 JG	98	}
ed9f1fb2 JG	99
1831ae68	100	static void test_add_null_schedule(void)
ed9f1fb2 JG	101	{
	102	enum lttng_rotation_status status;
	103
	104	status = lttng_session_add_rotation_schedule(session_name, NULL);
	105	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	106	"NULL schedule rejected by lttng_session_add_rotation_schedule()");
	107	}
	108
1831ae68	109	static void test_add_uninitialized_schedule(void)
ed9f1fb2 JG	110	{
	111	enum lttng_rotation_status status;
	112	struct lttng_rotation_schedule *size_schedule = NULL,
	113	*periodic_schedule = NULL;
	114
	115	size_schedule = lttng_rotation_schedule_size_threshold_create();
	116	ok(size_schedule, "Created a size threshold session rotation schedule");
	117
	118	status = lttng_session_add_rotation_schedule(session_name,
	119	size_schedule);
	120	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	121	"Uninitialized size schedule rejected by lttng_session_add_rotation_schedule()");
	122
	123	periodic_schedule = lttng_rotation_schedule_periodic_create();
	124	ok(periodic_schedule, "Created a periodic session rotation schedule");
	125
	126	status = lttng_session_add_rotation_schedule(session_name,
	127	periodic_schedule);
	128	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	129	"Uninitialized periodic schedule rejected by lttng_session_add_rotation_schedule()");
	130
	131	lttng_rotation_schedule_destroy(size_schedule);
	132	lttng_rotation_schedule_destroy(periodic_schedule);
	133	}
	134
1831ae68	135	static void test_remove_null_session(void)
ed9f1fb2 JG	136	{
	137	enum lttng_rotation_status status;
	138	struct lttng_rotation_schedule *size_schedule = NULL;
	139
	140	size_schedule = lttng_rotation_schedule_size_threshold_create();
	141
	142	status = lttng_session_remove_rotation_schedule(NULL, size_schedule);
	143	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	144	"NULL session name rejected by lttng_session_remove_rotation_schedule()");
4edd268b	145	lttng_rotation_schedule_destroy(size_schedule);
ed9f1fb2 JG	146	}
ed9f1fb2 JG	147
1831ae68	148	static void test_remove_null_schedule(void)
ed9f1fb2 JG	149	{
	150	enum lttng_rotation_status status;
	151
	152	status = lttng_session_remove_rotation_schedule(session_name, NULL);
	153	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	154	"NULL schedule rejected by lttng_session_remove_rotation_schedule()");
	155	}
	156
1831ae68	157	static void test_remove_uninitialized_schedule(void)
ed9f1fb2 JG	158	{
	159	enum lttng_rotation_status status;
	160	struct lttng_rotation_schedule *size_schedule = NULL,
	161	*periodic_schedule = NULL;
	162
	163	size_schedule = lttng_rotation_schedule_size_threshold_create();
	164	status = lttng_session_remove_rotation_schedule(session_name,
	165	size_schedule);
	166	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	167	"Uninitialized size schedule rejected by lttng_session_remove_rotation_schedule()");
	168
	169	periodic_schedule = lttng_rotation_schedule_periodic_create();
	170	status = lttng_session_remove_rotation_schedule(session_name,
	171	periodic_schedule);
	172	ok(status == LTTNG_ROTATION_STATUS_INVALID,
	173	"Uninitialized periodic schedule rejected by lttng_session_remove_rotation_schedule()");
	174
	175	lttng_rotation_schedule_destroy(size_schedule);
	176	lttng_rotation_schedule_destroy(periodic_schedule);
	177	}
	178
1831ae68	179	static void test_uninitialized_schedule_get(void)
ed9f1fb2 JG	180	{
	181	uint64_t value;
	182	enum lttng_rotation_status status;
	183	struct lttng_rotation_schedule *size_schedule = NULL,
	184	*periodic_schedule = NULL;
	185
	186	size_schedule = lttng_rotation_schedule_size_threshold_create();
	187	periodic_schedule = lttng_rotation_schedule_periodic_create();
	188
	189	status = lttng_rotation_schedule_size_threshold_get_threshold(
	190	size_schedule, &value);
	191	ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE,
	192	"Getter on size threshold rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default");
	193	status = lttng_rotation_schedule_periodic_get_period(periodic_schedule,
	194	&value);
	195	ok(status == LTTNG_ROTATION_STATUS_UNAVAILABLE,
	196	"Getter on periodic rotation schedule returns LTTNG_ROTATION_STATUS_UNAVAILABLE by default");
	197
	198	lttng_rotation_schedule_destroy(size_schedule);
	199	lttng_rotation_schedule_destroy(periodic_schedule);
	200
	201	}
	202
1831ae68	203	static void test_add_list_remove_schedule(
ed9f1fb2 JG	204	const struct lttng_rotation_schedule *original_schedule)
	205	{
	206	int ret;
	207	unsigned int schedules_count = 0;
	208	enum lttng_rotation_status status;
	209	const struct lttng_rotation_schedule *list_schedule;
	210	struct lttng_rotation_schedules *list_schedules;
	211
	212	status = lttng_session_add_rotation_schedule(session_name,
	213	original_schedule);
	214	ok(status == LTTNG_ROTATION_STATUS_OK,
	215	"Add a rotation schedule to session \'%s\'",
	216	session_name);
	217
	218	ret = lttng_session_list_rotation_schedules(session_name,
	219	&list_schedules);
	220	ok(ret == LTTNG_OK && list_schedules,
	221	"List rotation schedules of session \'%s\'",
	222	session_name);
	223
	224	status = lttng_rotation_schedules_get_count(list_schedules,
	225	&schedules_count);
	226	ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 1,
	227	"Listing returned 1 rotation schedule");
	228
	229	list_schedule = lttng_rotation_schedules_get_at_index(list_schedules,
	230	0);
	231	ok(list_schedule,
	232	"Obtain the first schedule of a schedules list");
	233
	234	ok(schedules_equal(original_schedule, list_schedule),
	235	"Schedule returned by the listing is equal to the reference schedule that was added");
	236
	237	status = lttng_session_remove_rotation_schedule(session_name,
	238	list_schedule);
	239	ok(status == LTTNG_ROTATION_STATUS_OK,
	240	"Remove rotation schedule returned by the schedules listing");
	241	lttng_rotation_schedules_destroy(list_schedules);
	242
	243	(void) lttng_session_list_rotation_schedules(session_name,
	244	&list_schedules);
	245	status = lttng_rotation_schedules_get_count(list_schedules,
	246	&schedules_count);
	247	ok(status == LTTNG_ROTATION_STATUS_OK && schedules_count == 0,
	248	"Listing returned 0 rotation schedules after removal");
	249
	250	}
	251
1831ae68	252	static void test_add_list_remove_size_schedule(void)
ed9f1fb2 JG	253	{
	254	struct lttng_rotation_schedule *size_schedule;
	255
	256	diag("Add, list, and remove a size threshold rotation schedule");
	257	size_schedule = lttng_rotation_schedule_size_threshold_create();
	258	(void) lttng_rotation_schedule_size_threshold_set_threshold(
	259	size_schedule, SIZE_THRESHOLD_BYTES);
	260	test_add_list_remove_schedule(size_schedule);
	261	lttng_rotation_schedule_destroy(size_schedule);
	262	}
	263
1831ae68	264	static void test_add_list_remove_periodic_schedule(void)
ed9f1fb2 JG	265	{
	266	struct lttng_rotation_schedule *periodic_schedule;
	267
	268	diag("Add, list, and remove a periodic rotation schedule");
	269	periodic_schedule = lttng_rotation_schedule_periodic_create();
	270	(void) lttng_rotation_schedule_periodic_set_period(
	271	periodic_schedule, PERIODIC_TIME_US);
	272	test_add_list_remove_schedule(periodic_schedule);
	273	lttng_rotation_schedule_destroy(periodic_schedule);
	274	}
	275
	276	int main(int argc, char **argv)
	277	{
	278	plan_tests(NUM_TESTS);
	279
	280	if (argc < 2) {
	281	diag("Usage: schedule_api SESSION_NAME");
	282	goto end;
	283	}
	284
	285	session_name = argv[1];
	286
	287	diag("Argument validation");
	288	test_add_null_session();
	289	test_add_null_schedule();
	290	test_add_uninitialized_schedule();
	291	test_remove_null_session();
	292	test_remove_null_schedule();
	293	test_remove_uninitialized_schedule();
	294	test_uninitialized_schedule_get();
	295
	296	test_add_list_remove_size_schedule();
	297	test_add_list_remove_periodic_schedule();
	298	end:
	299	return exit_status();
	300	}