[lttng-ust-java-tests.git] / lttng-ust-java-tests-common / src / main / java / org / lttng / ust / agent / integration / events / MultiSessionITBase.java

/*
 * Copyright (C) 2015, EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package org.lttng.ust.agent.integration.events;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;

import java.util.List;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.lttng.tools.ILttngSession;
import org.lttng.tools.ILttngSession.Domain;
import org.lttng.ust.agent.ILttngHandler;
import org.lttng.ust.agent.utils.TestPrintRunner;

/**
 * Base abstract class for tests with multiple concurrent tracing sessions
 */
@RunWith(TestPrintRunner.class)
public abstract class MultiSessionITBase {

    protected static final String EVENT_NAME_A = "EventA";
    protected static final String EVENT_NAME_B = "EventAB";
    protected static final String EVENT_NAME_C = "EventABC";
    protected static final String EVENT_NAME_D = "EventABCDÉ";

    private ILttngSession session1;
    private ILttngSession session2;
    private ILttngSession session3;

    /* Fields defined by the sub-class */
    protected ILttngHandler handlerA;
    protected ILttngHandler handlerB;
    protected ILttngHandler handlerC;
    protected ILttngHandler handlerD;

    protected abstract Domain getDomain();

    protected abstract boolean closeHandlers();

    protected abstract void sendEventsToLoggers();

    /**
     * Base test setup
     */
    @Before
    public void testSetup() {
        session1 = ILttngSession.createSession(null, getDomain());
        session2 = ILttngSession.createSession(null, getDomain());
        session3 = ILttngSession.createSession(null, getDomain());
    }

    /**
     * Base test teardown
     */
    @After
    public void testTeardown() {
        session1.close();
        session2.close();
        session3.close();

        if (closeHandlers()) {
            handlerA.close();
            handlerB.close();
            handlerC.close();
            handlerD.close();
        }

        handlerA = null;
        handlerB = null;
        handlerC = null;
        handlerD = null;
    }

    /**
     * Test with no events in any session.
     */
    @Test
    public void testNoEvents() {
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertTrue(output1.isEmpty());
        assertTrue(output2.isEmpty());
        assertTrue(output3.isEmpty());

        assertEquals(0, handlerA.getEventCount());
        assertEquals(0, handlerB.getEventCount());
        assertEquals(0, handlerC.getEventCount());
        assertEquals(0, handlerD.getEventCount());
    }

    /**
     * Test with all events enabled in one session only. Everything should be
     * sent through JNI, but only that session should keep the trace events.
     */
    @Test
    public void testAllEventsOneSession() {
        assertTrue(session1.enableAllEvents());
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(40, output1.size());
        assertTrue(output2.isEmpty());
        assertTrue(output3.isEmpty());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(10, handlerC.getEventCount());
        assertEquals(10, handlerD.getEventCount());
    }

    /**
     * Test with all events enabled in all sessions. All traces and handlers
     * should see every event that was logged.
     */
    @Test
    public void testAllEventsAllSessions() {
        assertTrue(session1.enableAllEvents());
        assertTrue(session2.enableAllEvents());
        assertTrue(session3.enableAllEvents());
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(40, output1.size());
        assertEquals(40, output2.size());
        assertEquals(40, output3.size());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(10, handlerC.getEventCount());
        assertEquals(10, handlerD.getEventCount());
    }

    /**
     * Test enabling some events in some sessions only.
     */
    @Test
    public void testSomeEvents() {
        assertTrue(session1.enableEvents(EVENT_NAME_A));
        assertTrue(session2.enableEvents(EVENT_NAME_B));
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(10, output1.size());
        assertEquals(10, output2.size());
        assertEquals(0, output3.size());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(0, handlerC.getEventCount());
        assertEquals(0, handlerD.getEventCount());
    }

    /**
     * Test with all events enabled in one session, and some others in another.
     * All events should arrive where expected, with no duplicates.
     */
    @Test
    public void testAllEventsAndSome() {
        assertTrue(session1.enableAllEvents());
        assertTrue(session2.enableEvents(EVENT_NAME_D));
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(40, output1.size());
        assertEquals(10, output2.size());
        assertEquals(0, output3.size());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(10, handlerC.getEventCount());
        assertEquals(10, handlerD.getEventCount());
    }

    /**
     * Test with enabling then disabling some events. Makes sure the refcounting
     * works properly.
     */
    @Test
    public void testSomeEventsAfterDisabling() {
        assertTrue(session1.enableEvents(EVENT_NAME_A, EVENT_NAME_B, EVENT_NAME_C));
        assertTrue(session2.enableEvents(EVENT_NAME_B, EVENT_NAME_C, EVENT_NAME_D));
        assertTrue(session3.enableEvents(EVENT_NAME_A));

        assertTrue(session1.disableEvents(EVENT_NAME_C));
        assertTrue(session2.disableEvents(EVENT_NAME_B, EVENT_NAME_C));
        assertTrue(session3.disableEvents(EVENT_NAME_A));

        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(20, output1.size());
        assertEquals(10, output2.size());
        assertEquals(0, output3.size());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(0, handlerC.getEventCount());
        assertEquals(10, handlerD.getEventCount());
    }

    /**
     * Test with a prefix in one session and a standard event in another.
     */
    @Test
    public void testPrefixAndEvent() {
        assertTrue(session1.enableEvents("EventAB*"));
        assertTrue(session3.enableEvents(EVENT_NAME_A));
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(30, output1.size());
        assertEquals(0, output2.size());
        assertEquals(10, output3.size());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(10, handlerC.getEventCount());
        assertEquals(10, handlerD.getEventCount());
    }

    /**
     * Test with all events enabled in one session, and an event prefix in
     * another. Once again, there should be no duplicates.
     */
    @Test
    public void testAllEventsAndPrefix() {
        assertTrue(session1.enableAllEvents());
        assertTrue(session2.enableEvents("EventABC*"));
        assertTrue(session1.start());
        assertTrue(session2.start());
        assertTrue(session3.start());

        sendEventsToLoggers();

        assertTrue(session1.stop());
        assertTrue(session2.stop());
        assertTrue(session3.stop());

        List<String> output1 = session1.view();
        List<String> output2 = session2.view();
        List<String> output3 = session3.view();
        assertNotNull(output1);
        assertNotNull(output2);
        assertNotNull(output3);
        assertEquals(40, output1.size());
        assertEquals(20, output2.size());
        assertEquals(0, output3.size());

        assertEquals(10, handlerA.getEventCount());
        assertEquals(10, handlerB.getEventCount());
        assertEquals(10, handlerC.getEventCount());
        assertEquals(10, handlerD.getEventCount());
    }
}
Commit	Line	Data
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
0e77c728	19	package org.lttng.ust.agent.integration.events;
e41ec02a AM	20
	21	import static org.junit.Assert.assertEquals;
	22	import static org.junit.Assert.assertNotNull;
	23	import static org.junit.Assert.assertTrue;
	24
	25	import java.util.List;
	26
	27	import org.junit.After;
	28	import org.junit.Before;
	29	import org.junit.Test;
64c5b50c	30	import org.junit.runner.RunWith;
45d1768c AM	31	import org.lttng.tools.ILttngSession;
45d1768c AM	32	import org.lttng.tools.ILttngSession.Domain;
e41ec02a	33	import org.lttng.ust.agent.ILttngHandler;
64c5b50c	34	import org.lttng.ust.agent.utils.TestPrintRunner;
e41ec02a AM	35
e41ec02a AM	36	/**
8a0613fa	37	* Base abstract class for tests with multiple concurrent tracing sessions
e41ec02a	38	*/
64c5b50c	39	@RunWith(TestPrintRunner.class)
7b82be36	40	public abstract class MultiSessionITBase {
e41ec02a AM	41
	42	protected static final String EVENT_NAME_A = "EventA";
	43	protected static final String EVENT_NAME_B = "EventAB";
	44	protected static final String EVENT_NAME_C = "EventABC";
6c2b24d5	45	protected static final String EVENT_NAME_D = "EventABCDÉ";
e41ec02a	46
45d1768c AM	47	private ILttngSession session1;
	48	private ILttngSession session2;
	49	private ILttngSession session3;
e41ec02a AM	50
	51	/* Fields defined by the sub-class */
	52	protected ILttngHandler handlerA;
	53	protected ILttngHandler handlerB;
	54	protected ILttngHandler handlerC;
	55	protected ILttngHandler handlerD;
	56
	57	protected abstract Domain getDomain();
	58
eca1a136 MJ	59	protected abstract boolean closeHandlers();
eca1a136 MJ	60
e41ec02a AM	61	protected abstract void sendEventsToLoggers();
e41ec02a AM	62
8a0613fa AM	63	/**
	64	* Base test setup
	65	*/
e41ec02a AM	66	@Before
e41ec02a AM	67	public void testSetup() {
ff620bef AM	68	session1 = ILttngSession.createSession(null, getDomain());
	69	session2 = ILttngSession.createSession(null, getDomain());
	70	session3 = ILttngSession.createSession(null, getDomain());
e41ec02a AM	71	}
e41ec02a AM	72
8a0613fa AM	73	/**
	74	* Base test teardown
	75	*/
e41ec02a AM	76	@After
	77	public void testTeardown() {
	78	session1.close();
	79	session2.close();
	80	session3.close();
	81
eca1a136 MJ	82	if (closeHandlers()) {
	83	handlerA.close();
	84	handlerB.close();
	85	handlerC.close();
	86	handlerD.close();
	87	}
e41ec02a AM	88
	89	handlerA = null;
	90	handlerB = null;
	91	handlerC = null;
	92	handlerD = null;
	93	}
	94
	95	/**
	96	* Test with no events in any session.
	97	*/
	98	@Test
	99	public void testNoEvents() {
	100	assertTrue(session1.start());
	101	assertTrue(session2.start());
	102	assertTrue(session3.start());
	103
	104	sendEventsToLoggers();
	105
	106	assertTrue(session1.stop());
	107	assertTrue(session2.stop());
	108	assertTrue(session3.stop());
	109
	110	List<String> output1 = session1.view();
	111	List<String> output2 = session2.view();
	112	List<String> output3 = session3.view();
	113	assertNotNull(output1);
	114	assertNotNull(output2);
	115	assertNotNull(output3);
	116	assertTrue(output1.isEmpty());
	117	assertTrue(output2.isEmpty());
	118	assertTrue(output3.isEmpty());
	119
	120	assertEquals(0, handlerA.getEventCount());
	121	assertEquals(0, handlerB.getEventCount());
	122	assertEquals(0, handlerC.getEventCount());
	123	assertEquals(0, handlerD.getEventCount());
	124	}
	125
	126	/**
	127	* Test with all events enabled in one session only. Everything should be
	128	* sent through JNI, but only that session should keep the trace events.
	129	*/
	130	@Test
	131	public void testAllEventsOneSession() {
	132	assertTrue(session1.enableAllEvents());
	133	assertTrue(session1.start());
	134	assertTrue(session2.start());
	135	assertTrue(session3.start());
	136
	137	sendEventsToLoggers();
	138
	139	assertTrue(session1.stop());
	140	assertTrue(session2.stop());
	141	assertTrue(session3.stop());
	142
	143	List<String> output1 = session1.view();
	144	List<String> output2 = session2.view();
	145	List<String> output3 = session3.view();
	146	assertNotNull(output1);
	147	assertNotNull(output2);
	148	assertNotNull(output3);
	149	assertEquals(40, output1.size());
	150	assertTrue(output2.isEmpty());
	151	assertTrue(output3.isEmpty());
152
153	assertEquals(10, handlerA.getEventCount());
154	assertEquals(10, handlerB.getEventCount());
155	assertEquals(10, handlerC.getEventCount());
156	assertEquals(10, handlerD.getEventCount());
157	}
158
159	/**
160	* Test with all events enabled in all sessions. All traces and handlers
161	* should see every event that was logged.
162	*/
163	@Test
164	public void testAllEventsAllSessions() {
165	assertTrue(session1.enableAllEvents());
166	assertTrue(session2.enableAllEvents());
167	assertTrue(session3.enableAllEvents());
168	assertTrue(session1.start());
169	assertTrue(session2.start());
170	assertTrue(session3.start());
171
172	sendEventsToLoggers();
173
174	assertTrue(session1.stop());
175	assertTrue(session2.stop());
176	assertTrue(session3.stop());
177
178	List<String> output1 = session1.view();
179	List<String> output2 = session2.view();
180	List<String> output3 = session3.view();
181	assertNotNull(output1);
182	assertNotNull(output2);
183	assertNotNull(output3);
184	assertEquals(40, output1.size());
185	assertEquals(40, output2.size());
186	assertEquals(40, output3.size());
187
188	assertEquals(10, handlerA.getEventCount());
189	assertEquals(10, handlerB.getEventCount());
190	assertEquals(10, handlerC.getEventCount());
191	assertEquals(10, handlerD.getEventCount());
192	}
193
194	/**
195	* Test enabling some events in some sessions only.
196	*/
197	@Test
198	public void testSomeEvents() {
199	assertTrue(session1.enableEvents(EVENT_NAME_A));
200	assertTrue(session2.enableEvents(EVENT_NAME_B));
201	assertTrue(session1.start());
202	assertTrue(session2.start());
203	assertTrue(session3.start());
204
205	sendEventsToLoggers();
206
207	assertTrue(session1.stop());
208	assertTrue(session2.stop());
209	assertTrue(session3.stop());
210
211	List<String> output1 = session1.view();
212	List<String> output2 = session2.view();
213	List<String> output3 = session3.view();
214	assertNotNull(output1);
215	assertNotNull(output2);
216	assertNotNull(output3);
217	assertEquals(10, output1.size());
218	assertEquals(10, output2.size());
219	assertEquals(0, output3.size());
220
221	assertEquals(10, handlerA.getEventCount());
222	assertEquals(10, handlerB.getEventCount());
223	assertEquals(0, handlerC.getEventCount());
224	assertEquals(0, handlerD.getEventCount());
225	}
226
227	/**
228	* Test with all events enabled in one session, and some others in another.
229	* All events should arrive where expected, with no duplicates.
230	*/
231	@Test
232	public void testAllEventsAndSome() {
233	assertTrue(session1.enableAllEvents());
234	assertTrue(session2.enableEvents(EVENT_NAME_D));
235	assertTrue(session1.start());
236	assertTrue(session2.start());
237	assertTrue(session3.start());
238
239	sendEventsToLoggers();
240
241	assertTrue(session1.stop());
242	assertTrue(session2.stop());
243	assertTrue(session3.stop());
244
245	List<String> output1 = session1.view();
246	List<String> output2 = session2.view();
247	List<String> output3 = session3.view();
248	assertNotNull(output1);
249	assertNotNull(output2);
250	assertNotNull(output3);
251	assertEquals(40, output1.size());
252	assertEquals(10, output2.size());
253	assertEquals(0, output3.size());
254
255	assertEquals(10, handlerA.getEventCount());
256	assertEquals(10, handlerB.getEventCount());
257	assertEquals(10, handlerC.getEventCount());
258	assertEquals(10, handlerD.getEventCount());
259	}
260
261	/**
262	* Test with enabling then disabling some events. Makes sure the refcounting
263	* works properly.
264	*/
265	@Test
266	public void testSomeEventsAfterDisabling() {
267	assertTrue(session1.enableEvents(EVENT_NAME_A, EVENT_NAME_B, EVENT_NAME_C));
268	assertTrue(session2.enableEvents(EVENT_NAME_B, EVENT_NAME_C, EVENT_NAME_D));
269	assertTrue(session3.enableEvents(EVENT_NAME_A));
270
271	assertTrue(session1.disableEvents(EVENT_NAME_C));
272	assertTrue(session2.disableEvents(EVENT_NAME_B, EVENT_NAME_C));
273	assertTrue(session3.disableEvents(EVENT_NAME_A));
274
275	assertTrue(session1.start());
276	assertTrue(session2.start());
277	assertTrue(session3.start());
278
279	sendEventsToLoggers();
280
281	assertTrue(session1.stop());
282	assertTrue(session2.stop());
283	assertTrue(session3.stop());
284
285	List<String> output1 = session1.view();
286	List<String> output2 = session2.view();
287	List<String> output3 = session3.view();
288	assertNotNull(output1);
289	assertNotNull(output2);
290	assertNotNull(output3);
291	assertEquals(20, output1.size());
292	assertEquals(10, output2.size());
293	assertEquals(0, output3.size());
294
295	assertEquals(10, handlerA.getEventCount());
296	assertEquals(10, handlerB.getEventCount());
297	assertEquals(0, handlerC.getEventCount());
298	assertEquals(10, handlerD.getEventCount());
299	}
300
301	/**
302	* Test with a prefix in one session and a standard event in another.
303	*/
304	@Test
305	public void testPrefixAndEvent() {
306	assertTrue(session1.enableEvents("EventAB*"));
307	assertTrue(session3.enableEvents(EVENT_NAME_A));
308	assertTrue(session1.start());
309	assertTrue(session2.start());
310	assertTrue(session3.start());
311
312	sendEventsToLoggers();
313
314	assertTrue(session1.stop());
315	assertTrue(session2.stop());
316	assertTrue(session3.stop());
317
318	List<String> output1 = session1.view();
319	List<String> output2 = session2.view();
320	List<String> output3 = session3.view();
321	assertNotNull(output1);
322	assertNotNull(output2);
323	assertNotNull(output3);
324	assertEquals(30, output1.size());
325	assertEquals(0, output2.size());
326	assertEquals(10, output3.size());
327
328	assertEquals(10, handlerA.getEventCount());
329	assertEquals(10, handlerB.getEventCount());
330	assertEquals(10, handlerC.getEventCount());
331	assertEquals(10, handlerD.getEventCount());
332	}
333
334	/**
335	* Test with all events enabled in one session, and an event prefix in
336	* another. Once again, there should be no duplicates.
337	*/
338	@Test
339	public void testAllEventsAndPrefix() {
340	assertTrue(session1.enableAllEvents());
341	assertTrue(session2.enableEvents("EventABC*"));
342	assertTrue(session1.start());
343	assertTrue(session2.start());
344	assertTrue(session3.start());
345
346	sendEventsToLoggers();
347
348	assertTrue(session1.stop());
349	assertTrue(session2.stop());
350	assertTrue(session3.stop());
351
352	List<String> output1 = session1.view();
353	List<String> output2 = session2.view();
354	List<String> output3 = session3.view();
355	assertNotNull(output1);
356	assertNotNull(output2);
357	assertNotNull(output3);
358	assertEquals(40, output1.size());
359	assertEquals(20, output2.size());
360	assertEquals(0, output3.size());
361
362	assertEquals(10, handlerA.getEventCount());
363	assertEquals(10, handlerB.getEventCount());
364	assertEquals(10, handlerC.getEventCount());
365	assertEquals(10, handlerD.getEventCount());
366	}
367	}