projects / lttng-ust-java-tests.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add copyright header to all source files
[lttng-ust-java-tests.git] / src / test / java / org / lttng / ust / agent / integration / MultiSessionTestBase.java
CommitLineData
2b408e85
AM		 1/*
2 * Copyright (C) 2015, EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
17 */
18
24b260d9 19package org.lttng.ust.agent.integration;
e41ec02a
AM		 20
21import static org.junit.Assert.assertEquals;
22import static org.junit.Assert.assertNotNull;
23import static org.junit.Assert.assertTrue;
24
25import java.util.List;
26
27import org.junit.After;
28import org.junit.Before;
29import org.junit.Test;
30import org.lttng.ust.agent.ILttngHandler;
31import org.lttng.ust.agent.utils.LttngSession;
32import org.lttng.ust.agent.utils.LttngSession.Domain;
33
34/**
35 * Tests with multiple concurrent tracing sessions
36 */
24b260d9 37public abstract class MultiSessionTestBase {
e41ec02a
AM		 38
39 protected static final String EVENT_NAME_A = "EventA";
40 protected static final String EVENT_NAME_B = "EventAB";
41 protected static final String EVENT_NAME_C = "EventABC";
42 protected static final String EVENT_NAME_D = "EventABCD";
43
44 private LttngSession session1;
45 private LttngSession session2;
46 private LttngSession session3;
47
48 /* Fields defined by the sub-class */
49 protected ILttngHandler handlerA;
50 protected ILttngHandler handlerB;
51 protected ILttngHandler handlerC;
52 protected ILttngHandler handlerD;
53
54 protected abstract Domain getDomain();
55
56 protected abstract void sendEventsToLoggers();
57
58 @Before
59 public void testSetup() {
60 session1 = new LttngSession(null, getDomain());
61 session2 = new LttngSession(null, getDomain());
62 session3 = new LttngSession(null, getDomain());
63 }
64
65 @After
66 public void testTeardown() {
67 session1.close();
68 session2.close();
69 session3.close();
70
71 handlerA.close();
72 handlerB.close();
73 handlerC.close();
74 handlerD.close();
75
76 handlerA = null;
77 handlerB = null;
78 handlerC = null;
79 handlerD = null;
80 }
81
82 /**
83 * Test with no events in any session.
84 */
85 @Test
86 public void testNoEvents() {
87 assertTrue(session1.start());
88 assertTrue(session2.start());
89 assertTrue(session3.start());
90
91 sendEventsToLoggers();
92
93 assertTrue(session1.stop());
94 assertTrue(session2.stop());
95 assertTrue(session3.stop());
96
97 List<String> output1 = session1.view();
98 List<String> output2 = session2.view();
99 List<String> output3 = session3.view();
100 assertNotNull(output1);
101 assertNotNull(output2);
102 assertNotNull(output3);
103 assertTrue(output1.isEmpty());
104 assertTrue(output2.isEmpty());
105 assertTrue(output3.isEmpty());
106
107 assertEquals(0, handlerA.getEventCount());
108 assertEquals(0, handlerB.getEventCount());
109 assertEquals(0, handlerC.getEventCount());
110 assertEquals(0, handlerD.getEventCount());
111 }
112
113 /**
114 * Test with all events enabled in one session only. Everything should be
115 * sent through JNI, but only that session should keep the trace events.
116 */
117 @Test
118 public void testAllEventsOneSession() {
119 assertTrue(session1.enableAllEvents());
120 assertTrue(session1.start());
121 assertTrue(session2.start());
122 assertTrue(session3.start());
123
124 sendEventsToLoggers();
125
126 assertTrue(session1.stop());
127 assertTrue(session2.stop());
128 assertTrue(session3.stop());
129
130 List<String> output1 = session1.view();
131 List<String> output2 = session2.view();
132 List<String> output3 = session3.view();
133 assertNotNull(output1);
134 assertNotNull(output2);
135 assertNotNull(output3);
136 assertEquals(40, output1.size());
137 assertTrue(output2.isEmpty());
138 assertTrue(output3.isEmpty());
139
140 assertEquals(10, handlerA.getEventCount());
141 assertEquals(10, handlerB.getEventCount());
142 assertEquals(10, handlerC.getEventCount());
143 assertEquals(10, handlerD.getEventCount());
144 }
145
146 /**
147 * Test with all events enabled in all sessions. All traces and handlers
148 * should see every event that was logged.
149 */
150 @Test
151 public void testAllEventsAllSessions() {
152 assertTrue(session1.enableAllEvents());
153 assertTrue(session2.enableAllEvents());
154 assertTrue(session3.enableAllEvents());
155 assertTrue(session1.start());
156 assertTrue(session2.start());
157 assertTrue(session3.start());
158
159 sendEventsToLoggers();
160
161 assertTrue(session1.stop());
162 assertTrue(session2.stop());
163 assertTrue(session3.stop());
164
165 List<String> output1 = session1.view();
166 List<String> output2 = session2.view();
167 List<String> output3 = session3.view();
168 assertNotNull(output1);
169 assertNotNull(output2);
170 assertNotNull(output3);
171 assertEquals(40, output1.size());
172 assertEquals(40, output2.size());
173 assertEquals(40, output3.size());
174
175 assertEquals(10, handlerA.getEventCount());
176 assertEquals(10, handlerB.getEventCount());
177 assertEquals(10, handlerC.getEventCount());
178 assertEquals(10, handlerD.getEventCount());
179 }
180
181 /**
182 * Test enabling some events in some sessions only.
183 */
184 @Test
185 public void testSomeEvents() {
186 assertTrue(session1.enableEvents(EVENT_NAME_A));
187 assertTrue(session2.enableEvents(EVENT_NAME_B));
188 assertTrue(session1.start());
189 assertTrue(session2.start());
190 assertTrue(session3.start());
191
192 sendEventsToLoggers();
193
194 assertTrue(session1.stop());
195 assertTrue(session2.stop());
196 assertTrue(session3.stop());
197
198 List<String> output1 = session1.view();
199 List<String> output2 = session2.view();
200 List<String> output3 = session3.view();
201 assertNotNull(output1);
202 assertNotNull(output2);
203 assertNotNull(output3);
204 assertEquals(10, output1.size());
205 assertEquals(10, output2.size());
206 assertEquals(0, output3.size());
207
208 assertEquals(10, handlerA.getEventCount());
209 assertEquals(10, handlerB.getEventCount());
210 assertEquals(0, handlerC.getEventCount());
211 assertEquals(0, handlerD.getEventCount());
212 }
213
214 /**
215 * Test with all events enabled in one session, and some others in another.
216 * All events should arrive where expected, with no duplicates.
217 */
218 @Test
219 public void testAllEventsAndSome() {
220 assertTrue(session1.enableAllEvents());
221 assertTrue(session2.enableEvents(EVENT_NAME_D));
222 assertTrue(session1.start());
223 assertTrue(session2.start());
224 assertTrue(session3.start());
225
226 sendEventsToLoggers();
227
228 assertTrue(session1.stop());
229 assertTrue(session2.stop());
230 assertTrue(session3.stop());
231
232 List<String> output1 = session1.view();
233 List<String> output2 = session2.view();
234 List<String> output3 = session3.view();
235 assertNotNull(output1);
236 assertNotNull(output2);
237 assertNotNull(output3);
238 assertEquals(40, output1.size());
239 assertEquals(10, output2.size());
240 assertEquals(0, output3.size());
241
242 assertEquals(10, handlerA.getEventCount());
243 assertEquals(10, handlerB.getEventCount());
244 assertEquals(10, handlerC.getEventCount());
245 assertEquals(10, handlerD.getEventCount());
246 }
247
248 /**
249 * Test with enabling then disabling some events. Makes sure the refcounting
250 * works properly.
251 */
252 @Test
253 public void testSomeEventsAfterDisabling() {
254 assertTrue(session1.enableEvents(EVENT_NAME_A, EVENT_NAME_B, EVENT_NAME_C));
255 assertTrue(session2.enableEvents(EVENT_NAME_B, EVENT_NAME_C, EVENT_NAME_D));
256 assertTrue(session3.enableEvents(EVENT_NAME_A));
257
258 assertTrue(session1.disableEvents(EVENT_NAME_C));
259 assertTrue(session2.disableEvents(EVENT_NAME_B, EVENT_NAME_C));
260 assertTrue(session3.disableEvents(EVENT_NAME_A));
261
262 assertTrue(session1.start());
263 assertTrue(session2.start());
264 assertTrue(session3.start());
265
266 sendEventsToLoggers();
267
268 assertTrue(session1.stop());
269 assertTrue(session2.stop());
270 assertTrue(session3.stop());
271
272 List<String> output1 = session1.view();
273 List<String> output2 = session2.view();
274 List<String> output3 = session3.view();
275 assertNotNull(output1);
276 assertNotNull(output2);
277 assertNotNull(output3);
278 assertEquals(20, output1.size());
279 assertEquals(10, output2.size());
280 assertEquals(0, output3.size());
281
282 assertEquals(10, handlerA.getEventCount());
283 assertEquals(10, handlerB.getEventCount());
284 assertEquals(0, handlerC.getEventCount());
285 assertEquals(10, handlerD.getEventCount());
286 }
287
288 /**
289 * Test with a prefix in one session and a standard event in another.
290 */
291 @Test
292 public void testPrefixAndEvent() {
293 assertTrue(session1.enableEvents("EventAB*"));
294 assertTrue(session3.enableEvents(EVENT_NAME_A));
295 assertTrue(session1.start());
296 assertTrue(session2.start());
297 assertTrue(session3.start());
298
299 sendEventsToLoggers();
300
301 assertTrue(session1.stop());
302 assertTrue(session2.stop());
303 assertTrue(session3.stop());
304
305 List<String> output1 = session1.view();
306 List<String> output2 = session2.view();
307 List<String> output3 = session3.view();
308 assertNotNull(output1);
309 assertNotNull(output2);
310 assertNotNull(output3);
311 assertEquals(30, output1.size());
312 assertEquals(0, output2.size());
313 assertEquals(10, output3.size());
314
315 assertEquals(10, handlerA.getEventCount());
316 assertEquals(10, handlerB.getEventCount());
317 assertEquals(10, handlerC.getEventCount());
318 assertEquals(10, handlerD.getEventCount());
319 }
320
321 /**
322 * Test with all events enabled in one session, and an event prefix in
323 * another. Once again, there should be no duplicates.
324 */
325 @Test
326 public void testAllEventsAndPrefix() {
327 assertTrue(session1.enableAllEvents());
328 assertTrue(session2.enableEvents("EventABC*"));
329 assertTrue(session1.start());
330 assertTrue(session2.start());
331 assertTrue(session3.start());
332
333 sendEventsToLoggers();
334
335 assertTrue(session1.stop());
336 assertTrue(session2.stop());
337 assertTrue(session3.stop());
338
339 List<String> output1 = session1.view();
340 List<String> output2 = session2.view();
341 List<String> output3 = session3.view();
342 assertNotNull(output1);
343 assertNotNull(output2);
344 assertNotNull(output3);
345 assertEquals(40, output1.size());
346 assertEquals(20, output2.size());
347 assertEquals(0, output3.size());
348
349 assertEquals(10, handlerA.getEventCount());
350 assertEquals(10, handlerB.getEventCount());
351 assertEquals(10, handlerC.getEventCount());
352 assertEquals(10, handlerD.getEventCount());
353 }
354}
Unnamed repository; edit this file 'description' to name the repository.
This page took 0.035237 seconds and 4 git commands to generate.