tests: unit: action: rotate_session
[lttng-tools.git] / tests / unit / test_action.c
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
12 #include <assert.h>
13 #include <inttypes.h>
14 #include <stdio.h>
15 #include <string.h>
16 #include <unistd.h>
17
18 #include <tap/tap.h>
19
20 #include <common/payload-view.h>
21 #include <common/payload.h>
22 #include <lttng/action/action-internal.h>
23 #include <lttng/action/action.h>
24 #include <lttng/action/firing-policy-internal.h>
25 #include <lttng/action/firing-policy.h>
26 #include <lttng/action/notify.h>
27 #include <lttng/action/rotate-session.h>
28
29 /* For error.h */
30 int lttng_opt_quiet = 1;
31 int lttng_opt_verbose;
32 int lttng_opt_mi;
33
34 #define NUM_TESTS 21
35
36 static void test_action_notify(void)
37 {
38 int ret;
39 enum lttng_action_status status;
40 struct lttng_action *notify_action = NULL,
41 *notify_action_from_buffer = NULL;
42 struct lttng_firing_policy *policy = NULL, *default_policy;
43 struct lttng_payload payload;
44
45 lttng_payload_init(&payload);
46
47 /* To set. */
48 policy = lttng_firing_policy_every_n_create(100);
49 /* For comparison. */
50 default_policy = lttng_firing_policy_every_n_create(1);
51
52 assert(policy && default_policy);
53
54 notify_action = lttng_action_notify_create();
55 ok(notify_action, "Create notify action");
56 ok(lttng_action_get_type(notify_action) == LTTNG_ACTION_TYPE_NOTIFY,
57 "Action has type LTTNG_ACTION_TYPE_NOTIFY");
58
59 /* Validate the default policy for a notify action. */
60 {
61 const struct lttng_firing_policy *cur_policy = NULL;
62 status = lttng_action_notify_get_firing_policy(
63 notify_action, &cur_policy);
64 ok(status == LTTNG_ACTION_STATUS_OK &&
65 lttng_firing_policy_is_equal(
66 default_policy,
67 cur_policy),
68 "Default policy is every n=1");
69 }
70
71 /* Set a custom policy. */
72 status = lttng_action_notify_set_firing_policy(notify_action, policy);
73 ok(status == LTTNG_ACTION_STATUS_OK, "Set firing policy");
74
75 /* Validate the custom policy for a notify action. */
76 {
77 const struct lttng_firing_policy *cur_policy = NULL;
78 status = lttng_action_notify_get_firing_policy(
79 notify_action, &cur_policy);
80 ok(status == LTTNG_ACTION_STATUS_OK &&
81 lttng_firing_policy_is_equal(
82 policy,
83 cur_policy),
84 "Notify action policy get");
85 }
86
87 ret = lttng_action_serialize(notify_action, &payload);
88 ok(ret == 0, "Action notify serialized");
89
90 {
91 struct lttng_payload_view view =
92 lttng_payload_view_from_payload(
93 &payload, 0, -1);
94 (void) lttng_action_create_from_payload(
95 &view, &notify_action_from_buffer);
96 }
97 ok(notify_action_from_buffer,
98 "Notify action created from payload is non-null");
99
100 ok(lttng_action_is_equal(notify_action, notify_action_from_buffer),
101 "Serialized and de-serialized notify action are equal");
102
103 lttng_firing_policy_destroy(default_policy);
104 lttng_firing_policy_destroy(policy);
105 lttng_action_destroy(notify_action);
106 lttng_action_destroy(notify_action_from_buffer);
107 lttng_payload_reset(&payload);
108 }
109
110 static void test_action_rotate_session(void)
111 {
112 int ret;
113 enum lttng_action_status status;
114 struct lttng_action *rotate_session_action = NULL,
115 *rotate_session_action_from_buffer = NULL;
116 struct lttng_firing_policy *policy = NULL, *default_policy;
117 struct lttng_payload payload;
118 const char *session_name = "my_session_name";
119 const char *get_session_name;
120
121 lttng_payload_init(&payload);
122
123 /* To set. */
124 policy = lttng_firing_policy_every_n_create(100);
125 /* For comparison. */
126 default_policy = lttng_firing_policy_every_n_create(1);
127
128 assert(policy && default_policy);
129
130 rotate_session_action = lttng_action_rotate_session_create();
131 ok(rotate_session_action, "Create rotate_session action");
132 ok(lttng_action_get_type(rotate_session_action) ==
133 LTTNG_ACTION_TYPE_ROTATE_SESSION,
134 "Action has type LTTNG_ACTION_TYPE_ROTATE_SESSION");
135
136 /* Session name setter. */
137 status = lttng_action_rotate_session_set_session_name(NULL, NULL);
138 ok(status == LTTNG_ACTION_STATUS_INVALID,
139 "Set session name (NULL,NULL) expect invalid");
140 status = lttng_action_rotate_session_set_session_name(
141 rotate_session_action, NULL);
142 ok(status == LTTNG_ACTION_STATUS_INVALID,
143 "Set session name (object,NULL) expect invalid");
144 status = lttng_action_rotate_session_set_session_name(
145 NULL, session_name);
146 ok(status == LTTNG_ACTION_STATUS_INVALID,
147 "Set session name (NULL,object) expect invalid");
148
149 /* Set the session name */
150 status = lttng_action_rotate_session_set_session_name(
151 rotate_session_action, session_name);
152 ok(status == LTTNG_ACTION_STATUS_OK, "Set session name");
153
154 status = lttng_action_rotate_session_get_session_name(
155 rotate_session_action, &get_session_name);
156 ok(status == LTTNG_ACTION_STATUS_OK &&
157 !strcmp(session_name, get_session_name),
158 "Get session name, expected `%s` got `%s`",
159 session_name, get_session_name);
160
161 /* Validate the default policy for a rotate_session action. */
162 {
163 const struct lttng_firing_policy *cur_policy = NULL;
164 status = lttng_action_rotate_session_get_firing_policy(
165 rotate_session_action, &cur_policy);
166 ok(status == LTTNG_ACTION_STATUS_OK &&
167 lttng_firing_policy_is_equal(
168 default_policy,
169 cur_policy),
170 "Default policy is every n=1");
171 }
172
173 /* Set a custom policy. */
174 status = lttng_action_rotate_session_set_firing_policy(
175 rotate_session_action, policy);
176 ok(status == LTTNG_ACTION_STATUS_OK, "Set firing policy");
177
178 /* Validate the custom policy for a rotate_session action. */
179 {
180 const struct lttng_firing_policy *cur_policy = NULL;
181 status = lttng_action_rotate_session_get_firing_policy(
182 rotate_session_action, &cur_policy);
183 ok(status == LTTNG_ACTION_STATUS_OK &&
184 lttng_firing_policy_is_equal(
185 policy,
186 cur_policy),
187 "rotate_session action policy get");
188 }
189
190 /* Ser/des tests. */
191 ret = lttng_action_serialize(rotate_session_action, &payload);
192 ok(ret == 0, "Action rotate_session serialized");
193
194 {
195 struct lttng_payload_view view =
196 lttng_payload_view_from_payload(
197 &payload, 0, -1);
198 (void) lttng_action_create_from_payload(
199 &view, &rotate_session_action_from_buffer);
200 }
201 ok(rotate_session_action_from_buffer,
202 "rotate_session action created from payload is non-null");
203
204 ok(lttng_action_is_equal(rotate_session_action,
205 rotate_session_action_from_buffer),
206 "Serialized and de-serialized rotate_session action are equal");
207
208 lttng_firing_policy_destroy(default_policy);
209 lttng_firing_policy_destroy(policy);
210 lttng_action_destroy(rotate_session_action);
211 lttng_action_destroy(rotate_session_action_from_buffer);
212 lttng_payload_reset(&payload);
213 }
214
215 int main(int argc, const char *argv[])
216 {
217 plan_tests(NUM_TESTS);
218 test_action_notify();
219 test_action_rotate_session();
220 return exit_status();
221 }
This page took 0.049144 seconds and 4 git commands to generate.