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

/*
 * 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 <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/rate-policy-internal.h>
#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_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 */
	/* 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_payload_reset(&payload);
}

int main(int argc, const char *argv[])
{
	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
	10	#include <assert.h>
	11	#include <inttypes.h>
	12	#include <stdio.h>
	13	#include <string.h>
	14	#include <unistd.h>
	15
	16	#include <tap/tap.h>
	17
	18	#include <common/payload-view.h>
	19	#include <common/payload.h>
	20	#include <lttng/action/rate-policy-internal.h>
	21	#include <lttng/action/rate-policy.h>
	22
	23	/* For error.h. */
	24	int lttng_opt_quiet = 1;
	25	int lttng_opt_verbose;
	26	int lttng_opt_mi;
	27
	28	#define NUM_TESTS 42
	29
	30	static void test_rate_policy_every_n(void)
	31	{
	32	enum lttng_rate_policy_status status;
	33	struct lttng_rate_policy policy_a = NULL; / Interval of 100. */
	34	struct lttng_rate_policy policy_b = NULL; / Interval of 100 */
	35	struct lttng_rate_policy policy_c = NULL; / Interval of 1 */
	36	struct lttng_rate_policy *policy_from_buffer = NULL;
	37	uint64_t interval_a_b = 100;
	38	uint64_t interval_c = 1;
	39	uint64_t interval_query = 0;
	40	struct lttng_payload payload;
	41
	42	lttng_payload_init(&payload);
	43
	44	policy_a = lttng_rate_policy_every_n_create(interval_a_b);
	45	policy_b = lttng_rate_policy_every_n_create(interval_a_b);
	46	policy_c = lttng_rate_policy_every_n_create(interval_c);
	47	ok(policy_a != NULL,
	48	"Rate policy every n A created: interval: %" PRIu64,
	49	interval_a_b);
	50	ok(policy_b != NULL,
	51	"Rate policy every n B created: interval: %" PRIu64,
	52	interval_a_b);
	53	ok(policy_c != NULL,
	54	"Rate policy every n C created: interval: %" PRIu64,
	55	interval_c);
	56
	57	ok(LTTNG_RATE_POLICY_TYPE_EVERY_N ==
	58	lttng_rate_policy_get_type(policy_a),
	59	"Type is LTTNG_RATE_POLICY_TYPE_EVERY_N");
	60
	61	/* Getter tests */
	62	status = lttng_rate_policy_every_n_get_interval(NULL, NULL);
	63	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
	64	"Get interval returns INVALID");
65
66	status = lttng_rate_policy_every_n_get_interval(NULL, &interval_query);
67	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
68	"Get interval returns INVALID");
69
70	status = lttng_rate_policy_every_n_get_interval(policy_a, NULL);
71	ok(status == LTTNG_RATE_POLICY_STATUS_INVALID,
72	"Get interval returns INVALID");
73
74	status = lttng_rate_policy_every_n_get_interval(
75	policy_a, &interval_query);
76	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
77	interval_query == interval_a_b,
78	" Getting interval A");
79
80	status = lttng_rate_policy_every_n_get_interval(
81	policy_b, &interval_query);
82	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
83	interval_query == interval_a_b,
84	" Getting interval B");
85
86	status = lttng_rate_policy_every_n_get_interval(
87	policy_c, &interval_query);
88	ok(status == LTTNG_RATE_POLICY_STATUS_OK &&
89	interval_query == interval_c,
90	" Getting interval C");
91
92	/* is_equal tests */
93	/* TODO: this is the behaviour introduced by the
94	* lttng_condition_is_equal back in 2017 do we want to fix this and
95	* return true if both are NULL?
96	*/
97	ok(false == lttng_rate_policy_is_equal(NULL, NULL),
98	"is equal (NULL,NULL)");
99	ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
100	"is equal (object, NULL)");
101	ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
102	" is equal (NULL, object)");
103	ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
104	"is equal (object A, object A)");
105
106	ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
107	"is equal (object A, object B");
108	ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
109	"is equal (object B, object A");
110
111	ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
112	"is equal (object A, object C)");
113	ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
114	"is equal (object C, object A)");
115
116	/* Serialization and create_from buffer. */
117	ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
118	{
119	struct lttng_payload_view view =
120	lttng_payload_view_from_payload(
121	&payload, 0, -1);
122
123	ok(lttng_rate_policy_create_from_payload(
124	&view, &policy_from_buffer) > 0 &&
125	policy_from_buffer != NULL,
126	"Deserializing");
127	}
128
129	ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
130	"serialized and from buffer are equal");
131
132	lttng_rate_policy_destroy(policy_a);
133	lttng_rate_policy_destroy(policy_b);
134	lttng_rate_policy_destroy(policy_c);
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 */
202	/* TODO: this is the behaviour introduced by the
203	* lttng_condition_is_equal back in 2017 do we want to fix this and
204	* return true if both are NULL?
205	*/
206	ok(false == lttng_rate_policy_is_equal(NULL, NULL),
207	"is equal (NULL,NULL)");
208	ok(false == lttng_rate_policy_is_equal(policy_a, NULL),
209	"is equal (object, NULL)");
210	ok(false == lttng_rate_policy_is_equal(NULL, policy_a),
211	" is equal (NULL, object)");
212	ok(true == lttng_rate_policy_is_equal(policy_a, policy_a),
213	"is equal (object A, object A)");
214
215	ok(true == lttng_rate_policy_is_equal(policy_a, policy_b),
216	"is equal (object A, object B");
217	ok(true == lttng_rate_policy_is_equal(policy_b, policy_a),
218	"is equal (object B, object A");
219
220	ok(false == lttng_rate_policy_is_equal(policy_a, policy_c),
221	"is equal (object A, object C)");
222	ok(false == lttng_rate_policy_is_equal(policy_c, policy_a),
223	"is equal (object C, object A)");
224
225	/* Serialization and create_from buffer. */
226	ok(lttng_rate_policy_serialize(policy_a, &payload) == 0, "Serializing");
227	{
228	struct lttng_payload_view view =
229	lttng_payload_view_from_payload(
230	&payload, 0, -1);
231
232	ok(lttng_rate_policy_create_from_payload(
233	&view, &policy_from_buffer) > 0 &&
234	policy_from_buffer != NULL,
235	"Deserializing");
236	}
237
238	ok(lttng_rate_policy_is_equal(policy_a, policy_from_buffer),
239	"serialized and from buffer are equal");
240
241	lttng_rate_policy_destroy(policy_a);
242	lttng_rate_policy_destroy(policy_b);
243	lttng_rate_policy_destroy(policy_c);
244	lttng_payload_reset(&payload);
245	}
246
247	int main(int argc, const char *argv[])
248	{
249	plan_tests(NUM_TESTS);
250	test_rate_policy_every_n();
251	test_rate_policy_once_after_n();
252	return exit_status();
253	}