2 * Copyright (C) 2015, EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
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.
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.
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.
19 package org
.lttng
.ust
.agent
.integration
;
21 import static org
.junit
.Assert
.assertEquals
;
22 import static org
.junit
.Assert
.assertNotNull
;
23 import static org
.junit
.Assert
.assertTrue
;
25 import java
.util
.List
;
27 import org
.junit
.After
;
28 import org
.junit
.Before
;
29 import org
.junit
.Test
;
30 import org
.lttng
.ust
.agent
.ILttngHandler
;
31 import org
.lttng
.ust
.agent
.utils
.LttngSession
;
32 import org
.lttng
.ust
.agent
.utils
.LttngSession
.Domain
;
35 * Tests with multiple concurrent tracing sessions
37 public abstract class MultiSessionTestBase
{
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";
44 private LttngSession session1
;
45 private LttngSession session2
;
46 private LttngSession session3
;
48 /* Fields defined by the sub-class */
49 protected ILttngHandler handlerA
;
50 protected ILttngHandler handlerB
;
51 protected ILttngHandler handlerC
;
52 protected ILttngHandler handlerD
;
54 protected abstract Domain
getDomain();
56 protected abstract void sendEventsToLoggers();
59 public void testSetup() {
60 session1
= new LttngSession(null, getDomain());
61 session2
= new LttngSession(null, getDomain());
62 session3
= new LttngSession(null, getDomain());
66 public void testTeardown() {
83 * Test with no events in any session.
86 public void testNoEvents() {
87 assertTrue(session1
.start());
88 assertTrue(session2
.start());
89 assertTrue(session3
.start());
91 sendEventsToLoggers();
93 assertTrue(session1
.stop());
94 assertTrue(session2
.stop());
95 assertTrue(session3
.stop());
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());
107 assertEquals(0, handlerA
.getEventCount());
108 assertEquals(0, handlerB
.getEventCount());
109 assertEquals(0, handlerC
.getEventCount());
110 assertEquals(0, handlerD
.getEventCount());
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.
118 public void testAllEventsOneSession() {
119 assertTrue(session1
.enableAllEvents());
120 assertTrue(session1
.start());
121 assertTrue(session2
.start());
122 assertTrue(session3
.start());
124 sendEventsToLoggers();
126 assertTrue(session1
.stop());
127 assertTrue(session2
.stop());
128 assertTrue(session3
.stop());
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());
140 assertEquals(10, handlerA
.getEventCount());
141 assertEquals(10, handlerB
.getEventCount());
142 assertEquals(10, handlerC
.getEventCount());
143 assertEquals(10, handlerD
.getEventCount());
147 * Test with all events enabled in all sessions. All traces and handlers
148 * should see every event that was logged.
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());
159 sendEventsToLoggers();
161 assertTrue(session1
.stop());
162 assertTrue(session2
.stop());
163 assertTrue(session3
.stop());
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());
175 assertEquals(10, handlerA
.getEventCount());
176 assertEquals(10, handlerB
.getEventCount());
177 assertEquals(10, handlerC
.getEventCount());
178 assertEquals(10, handlerD
.getEventCount());
182 * Test enabling some events in some sessions only.
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());
192 sendEventsToLoggers();
194 assertTrue(session1
.stop());
195 assertTrue(session2
.stop());
196 assertTrue(session3
.stop());
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());
208 assertEquals(10, handlerA
.getEventCount());
209 assertEquals(10, handlerB
.getEventCount());
210 assertEquals(0, handlerC
.getEventCount());
211 assertEquals(0, handlerD
.getEventCount());
215 * Test with all events enabled in one session, and some others in another.
216 * All events should arrive where expected, with no duplicates.
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());
226 sendEventsToLoggers();
228 assertTrue(session1
.stop());
229 assertTrue(session2
.stop());
230 assertTrue(session3
.stop());
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());
242 assertEquals(10, handlerA
.getEventCount());
243 assertEquals(10, handlerB
.getEventCount());
244 assertEquals(10, handlerC
.getEventCount());
245 assertEquals(10, handlerD
.getEventCount());
249 * Test with enabling then disabling some events. Makes sure the refcounting
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
));
258 assertTrue(session1
.disableEvents(EVENT_NAME_C
));
259 assertTrue(session2
.disableEvents(EVENT_NAME_B
, EVENT_NAME_C
));
260 assertTrue(session3
.disableEvents(EVENT_NAME_A
));
262 assertTrue(session1
.start());
263 assertTrue(session2
.start());
264 assertTrue(session3
.start());
266 sendEventsToLoggers();
268 assertTrue(session1
.stop());
269 assertTrue(session2
.stop());
270 assertTrue(session3
.stop());
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());
282 assertEquals(10, handlerA
.getEventCount());
283 assertEquals(10, handlerB
.getEventCount());
284 assertEquals(0, handlerC
.getEventCount());
285 assertEquals(10, handlerD
.getEventCount());
289 * Test with a prefix in one session and a standard event in another.
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());
299 sendEventsToLoggers();
301 assertTrue(session1
.stop());
302 assertTrue(session2
.stop());
303 assertTrue(session3
.stop());
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());
315 assertEquals(10, handlerA
.getEventCount());
316 assertEquals(10, handlerB
.getEventCount());
317 assertEquals(10, handlerC
.getEventCount());
318 assertEquals(10, handlerD
.getEventCount());
322 * Test with all events enabled in one session, and an event prefix in
323 * another. Once again, there should be no duplicates.
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());
333 sendEventsToLoggers();
335 assertTrue(session1
.stop());
336 assertTrue(session2
.stop());
337 assertTrue(session3
.stop());
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());
349 assertEquals(10, handlerA
.getEventCount());
350 assertEquals(10, handlerB
.getEventCount());
351 assertEquals(10, handlerC
.getEventCount());
352 assertEquals(10, handlerD
.getEventCount());
This page took 0.036745 seconds and 4 git commands to generate.