Rename firing policy to rate policy
[lttng-tools.git] / tests / unit / test_rate_policy.c
CommitLineData
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. */
24int lttng_opt_quiet = 1;
25int lttng_opt_verbose;
26int lttng_opt_mi;
27
28#define NUM_TESTS 42
29
30static 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
138static 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
247int 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}
This page took 0.032276 seconds and 4 git commands to generate.