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

/*
 * Unit tests for the rate policy object API.
 *
 * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 */

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

#include <tap/tap.h>

#include <common/payload-view.hpp>
#include <common/payload.hpp>
#include <lttng/action/rate-policy-internal.hpp>
#include <lttng/action/rate-policy.h>

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

#define NUM_TESTS 42

static void test_rate_policy_every_n(void)
{
	enum lttng_rate_policy_status status;
	struct lttng_rate_policy *policy_a = NULL; /* Interval of 100. */
	struct lttng_rate_policy *policy_b = NULL; /* Interval of 100 */
	struct lttng_rate_policy *policy_c = NULL; /* Interval of 1 */
	struct lttng_rate_policy *policy_from_buffer = NULL;
	uint64_t interval_a_b = 100;
	uint64_t interval_c = 1;
	uint64_t interval_query = 0;
	struct lttng_payload payload;

	lttng_payload_init(&payload);

	policy_a = lttng_rate_policy_every_n_create(interval_a_b);
	policy_b = lttng_rate_policy_every_n_create(interval_a_b);
	policy_c = lttng_rate_policy_every_n_create(interval_c);
	ok(policy_a != NULL,
			"Rate policy every n A created: interval: %" PRIu64,
			interval_a_b);
	ok(policy_b != NULL,
			"Rate policy every n B created: interval: %" PRIu64,
			interval_a_b);
	ok(policy_c != NULL,
			"Rate policy every n C created: interval: %" PRIu64,
			interval_c);

	ok(LTTNG_RATE_POLICY_TYPE_EVERY_N ==
					lttng_rate_policy_get_type(policy_a),
			"Type is LTTNG_RATE_POLICY_TYPE_EVERY_N");

	/* Getter tests */
	status = lttng_rate_policy_every_n_get_interval(NULL, NULL);
	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
			"Get interval returns INVALID");

	status = lttng_rate_policy_every_n_get_interval(NULL, &interval_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
			"Get interval returns INVALID");

	status = lttng_rate_policy_every_n_get_interval(policy_a, NULL);
	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
			"Get interval returns INVALID");

	status = lttng_rate_policy_every_n_get_interval(
			policy_a, &interval_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
					interval_query == interval_a_b,
			" Getting interval A");

	status = lttng_rate_policy_every_n_get_interval(
			policy_b, &interval_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
					interval_query == interval_a_b,
			" Getting interval B");

	status = lttng_rate_policy_every_n_get_interval(
			policy_c, &interval_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
					interval_query == interval_c,
			" Getting interval C");

	/* is_equal tests */
	/* TODO: this is the behaviour introduced by the
	 * lttng_condition_is_equal back in 2017 do we want to fix this and
	 * return true if both are NULL?
	 */
	ok(false == lttng_rate_policy_is_equal(NULL, NULL),
			"is equal (NULL,NULL)");
	ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
			"is equal (object, NULL)");
	ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
			" is equal (NULL, object)");
	ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
			"is equal (object A, object A)");

	ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
			"is equal (object A, object B");
	ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
			"is equal (object B, object A");

	ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
			"is equal (object A, object C)");
	ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
			"is equal (object C, object A)");

	/* Serialization and create_from buffer. */
	ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);

		ok(lttng_rate_policy_create_from_payload(
				   &view, &policy_from_buffer) > 0 &&
						policy_from_buffer != NULL,
				"Deserializing");
	}

	ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
			"serialized and from buffer are equal");

	lttng_rate_policy_destroy(policy_a);
	lttng_rate_policy_destroy(policy_b);
	lttng_rate_policy_destroy(policy_c);
	lttng_rate_policy_destroy(policy_from_buffer);
	lttng_payload_reset(&payload);
}

static void test_rate_policy_once_after_n(void)
{
	enum lttng_rate_policy_status status;
	struct lttng_rate_policy *policy_a = NULL; /* Threshold of 100. */
	struct lttng_rate_policy *policy_b = NULL; /* threshold of 100 */
	struct lttng_rate_policy *policy_c = NULL; /* threshold of 1 */
	struct lttng_rate_policy *policy_from_buffer = NULL;
	uint64_t threshold_a_b = 100;
	uint64_t threshold_c = 1;
	uint64_t threshold_query = 0;
	struct lttng_payload payload;

	lttng_payload_init(&payload);

	policy_a = lttng_rate_policy_once_after_n_create(threshold_a_b);
	policy_b = lttng_rate_policy_once_after_n_create(threshold_a_b);
	policy_c = lttng_rate_policy_once_after_n_create(threshold_c);
	ok(policy_a != NULL,
			"Rate policy every n A created: threshold: %" PRIu64,
			threshold_a_b);
	ok(policy_b != NULL,
			"Rate policy every n B created: threshold: %" PRIu64,
			threshold_a_b);
	ok(policy_c != NULL,
			"Rate policy every n C created: threshold: %" PRIu64,
			threshold_c);

	ok(LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N ==
					lttng_rate_policy_get_type(policy_a),
			"Type is LTTNG_RATE_POLICY_TYPE_once_after_n");

	/* Getter tests */
	status = lttng_rate_policy_once_after_n_get_threshold(NULL, NULL);
	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
			"Get threshold returns INVALID");

	status = lttng_rate_policy_once_after_n_get_threshold(
			NULL, &threshold_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
			"Get threshold returns INVALID");

	status = lttng_rate_policy_once_after_n_get_threshold(policy_a, NULL);
	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
			"Get threshold returns INVALID");

	status = lttng_rate_policy_once_after_n_get_threshold(
			policy_a, &threshold_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
					threshold_query == threshold_a_b,
			" Getting threshold A");

	status = lttng_rate_policy_once_after_n_get_threshold(
			policy_b, &threshold_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
					threshold_query == threshold_a_b,
			" Getting threshold B");

	status = lttng_rate_policy_once_after_n_get_threshold(
			policy_c, &threshold_query);
	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
					threshold_query == threshold_c,
			" Getting threshold C");

	/* is_equal tests */
	ok(false == lttng_rate_policy_is_equal(NULL, NULL),
			"is equal (NULL,NULL)");
	ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
			"is equal (object, NULL)");
	ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
			" is equal (NULL, object)");
	ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
			"is equal (object A, object A)");

	ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
			"is equal (object A, object B");
	ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
			"is equal (object B, object A");

	ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
			"is equal (object A, object C)");
	ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
			"is equal (object C, object A)");

	/* Serialization and create_from buffer. */
	ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
	{
		struct lttng_payload_view view =
				lttng_payload_view_from_payload(
						&payload, 0, -1);

		ok(lttng_rate_policy_create_from_payload(
				   &view, &policy_from_buffer) > 0 &&
						policy_from_buffer != NULL,
				"Deserializing");
	}

	ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
			"serialized and from buffer are equal");

	lttng_rate_policy_destroy(policy_a);
	lttng_rate_policy_destroy(policy_b);
	lttng_rate_policy_destroy(policy_c);
	lttng_rate_policy_destroy(policy_from_buffer);
	lttng_payload_reset(&payload);
}

int main(void)
{
	plan_tests(NUM_TESTS);
	test_rate_policy_every_n();
	test_rate_policy_once_after_n();
	return exit_status();
}
Commit	Line	Data
7f4d5b07 JR	1	/*
	2	* Unit tests for the rate policy object API.
	3	*
	4	* Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
	5	*
	6	* SPDX-License-Identifier: LGPL-2.1-only
	7	*
	8	*/
	9
7f4d5b07 JR	10	#include <inttypes.h>
	11	#include <stdio.h>
	12	#include <string.h>
	13	#include <unistd.h>
	14
	15	#include <tap/tap.h>
	16
c9e313bc SM	17	#include <common/payload-view.hpp>
	18	#include <common/payload.hpp>
	19	#include <lttng/action/rate-policy-internal.hpp>
7f4d5b07 JR	20	#include <lttng/action/rate-policy.h>
	21
	22	/* For error.h. */
	23	int lttng_opt_quiet = 1;
	24	int lttng_opt_verbose;
	25	int lttng_opt_mi;
	26
	27	#define NUM_TESTS 42
	28
	29	static void test_rate_policy_every_n(void)
	30	{
	31	enum lttng_rate_policy_status status;
	32	struct lttng_rate_policy policy_a = NULL; / Interval of 100. */
	33	struct lttng_rate_policy policy_b = NULL; / Interval of 100 */
	34	struct lttng_rate_policy policy_c = NULL; / Interval of 1 */
	35	struct lttng_rate_policy *policy_from_buffer = NULL;
	36	uint64_t interval_a_b = 100;
	37	uint64_t interval_c = 1;
	38	uint64_t interval_query = 0;
	39	struct lttng_payload payload;
	40
	41	lttng_payload_init(&payload);
	42
	43	policy_a = lttng_rate_policy_every_n_create(interval_a_b);
	44	policy_b = lttng_rate_policy_every_n_create(interval_a_b);
	45	policy_c = lttng_rate_policy_every_n_create(interval_c);
	46	ok(policy_a != NULL,
	47	"Rate policy every n A created: interval: %" PRIu64,
	48	interval_a_b);
	49	ok(policy_b != NULL,
	50	"Rate policy every n B created: interval: %" PRIu64,
	51	interval_a_b);
	52	ok(policy_c != NULL,
	53	"Rate policy every n C created: interval: %" PRIu64,
	54	interval_c);
	55
	56	ok(LTTNG_RATE_POLICY_TYPE_EVERY_N ==
	57	lttng_rate_policy_get_type(policy_a),
	58	"Type is LTTNG_RATE_POLICY_TYPE_EVERY_N");
	59
	60	/* Getter tests */
	61	status = lttng_rate_policy_every_n_get_interval(NULL, NULL);
	62	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	63	"Get interval returns INVALID");
	64
	65	status = lttng_rate_policy_every_n_get_interval(NULL, &interval_query);
	66	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	67	"Get interval returns INVALID");
	68
	69	status = lttng_rate_policy_every_n_get_interval(policy_a, NULL);
	70	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	71	"Get interval returns INVALID");
	72
	73	status = lttng_rate_policy_every_n_get_interval(
	74	policy_a, &interval_query);
	75	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
	76	interval_query == interval_a_b,
	77	" Getting interval A");
	78
	79	status = lttng_rate_policy_every_n_get_interval(
	80	policy_b, &interval_query);
	81	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
	82	interval_query == interval_a_b,
	83	" Getting interval B");
84
85	status = lttng_rate_policy_every_n_get_interval(
86	policy_c, &interval_query);
87	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
88	interval_query == interval_c,
89	" Getting interval C");
90
91	/* is_equal tests */
92	/* TODO: this is the behaviour introduced by the
93	* lttng_condition_is_equal back in 2017 do we want to fix this and
94	* return true if both are NULL?
95	*/
96	ok(false == lttng_rate_policy_is_equal(NULL, NULL),
97	"is equal (NULL,NULL)");
98	ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
99	"is equal (object, NULL)");
100	ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
101	" is equal (NULL, object)");
102	ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
103	"is equal (object A, object A)");
104
105	ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
106	"is equal (object A, object B");
107	ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
108	"is equal (object B, object A");
109
110	ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
111	"is equal (object A, object C)");
112	ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
113	"is equal (object C, object A)");
114
115	/* Serialization and create_from buffer. */
116	ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
117	{
118	struct lttng_payload_view view =
119	lttng_payload_view_from_payload(
120	&payload, 0, -1);
121
122	ok(lttng_rate_policy_create_from_payload(
123	&view, &policy_from_buffer) > 0 &&
124	policy_from_buffer != NULL,
125	"Deserializing");
126	}
127
128	ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
129	"serialized and from buffer are equal");
130
131	lttng_rate_policy_destroy(policy_a);
132	lttng_rate_policy_destroy(policy_b);
133	lttng_rate_policy_destroy(policy_c);
1f38e81c	134	lttng_rate_policy_destroy(policy_from_buffer);
7f4d5b07 JR	135	lttng_payload_reset(&payload);
	136	}
	137
	138	static void test_rate_policy_once_after_n(void)
	139	{
	140	enum lttng_rate_policy_status status;
	141	struct lttng_rate_policy policy_a = NULL; / Threshold of 100. */
	142	struct lttng_rate_policy policy_b = NULL; / threshold of 100 */
	143	struct lttng_rate_policy policy_c = NULL; / threshold of 1 */
	144	struct lttng_rate_policy *policy_from_buffer = NULL;
	145	uint64_t threshold_a_b = 100;
	146	uint64_t threshold_c = 1;
	147	uint64_t threshold_query = 0;
	148	struct lttng_payload payload;
	149
	150	lttng_payload_init(&payload);
	151
	152	policy_a = lttng_rate_policy_once_after_n_create(threshold_a_b);
	153	policy_b = lttng_rate_policy_once_after_n_create(threshold_a_b);
	154	policy_c = lttng_rate_policy_once_after_n_create(threshold_c);
	155	ok(policy_a != NULL,
	156	"Rate policy every n A created: threshold: %" PRIu64,
	157	threshold_a_b);
	158	ok(policy_b != NULL,
	159	"Rate policy every n B created: threshold: %" PRIu64,
	160	threshold_a_b);
	161	ok(policy_c != NULL,
	162	"Rate policy every n C created: threshold: %" PRIu64,
	163	threshold_c);
	164
	165	ok(LTTNG_RATE_POLICY_TYPE_ONCE_AFTER_N ==
	166	lttng_rate_policy_get_type(policy_a),
	167	"Type is LTTNG_RATE_POLICY_TYPE_once_after_n");
	168
	169	/* Getter tests */
	170	status = lttng_rate_policy_once_after_n_get_threshold(NULL, NULL);
	171	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	172	"Get threshold returns INVALID");
	173
	174	status = lttng_rate_policy_once_after_n_get_threshold(
	175	NULL, &threshold_query);
	176	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	177	"Get threshold returns INVALID");
	178
	179	status = lttng_rate_policy_once_after_n_get_threshold(policy_a, NULL);
	180	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	181	"Get threshold returns INVALID");
	182
	183	status = lttng_rate_policy_once_after_n_get_threshold(
	184	policy_a, &threshold_query);
	185	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
	186	threshold_query == threshold_a_b,
	187	" Getting threshold A");
	188
	189	status = lttng_rate_policy_once_after_n_get_threshold(
	190	policy_b, &threshold_query);
	191	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
	192	threshold_query == threshold_a_b,
	193	" Getting threshold B");
	194
	195	status = lttng_rate_policy_once_after_n_get_threshold(
	196	policy_c, &threshold_query);
	197	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
	198	threshold_query == threshold_c,
199	" Getting threshold C");
200
201	/* is_equal tests */
7f4d5b07 JR	202	ok(false == lttng_rate_policy_is_equal(NULL, NULL),
	203	"is equal (NULL,NULL)");
	204	ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
	205	"is equal (object, NULL)");
	206	ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
	207	" is equal (NULL, object)");
	208	ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
	209	"is equal (object A, object A)");
	210
	211	ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
	212	"is equal (object A, object B");
	213	ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
	214	"is equal (object B, object A");
	215
	216	ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
	217	"is equal (object A, object C)");
	218	ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
	219	"is equal (object C, object A)");
	220
	221	/* Serialization and create_from buffer. */
	222	ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
	223	{
	224	struct lttng_payload_view view =
	225	lttng_payload_view_from_payload(
	226	&payload, 0, -1);
	227
	228	ok(lttng_rate_policy_create_from_payload(
	229	&view, &policy_from_buffer) > 0 &&
	230	policy_from_buffer != NULL,
	231	"Deserializing");
	232	}
	233
	234	ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
	235	"serialized and from buffer are equal");
	236
	237	lttng_rate_policy_destroy(policy_a);
	238	lttng_rate_policy_destroy(policy_b);
	239	lttng_rate_policy_destroy(policy_c);
1f38e81c	240	lttng_rate_policy_destroy(policy_from_buffer);
7f4d5b07 JR	241	lttng_payload_reset(&payload);
	242	}
	243
f46376a1	244	int main(void)
7f4d5b07 JR	245	{
	246	plan_tests(NUM_TESTS);
	247	test_rate_policy_every_n();
	248	test_rate_policy_once_after_n();
	249	return exit_status();
	250	}