Add some integration tests for JUL

[lttng-ust-java-tests.git] / src / org / lttng / ust / agent / integration / jul / JulEnabledEventsTest.java

diff --git a/src/org/lttng/ust/agent/integration/jul/JulEnabledEventsTest.java b/src/org/lttng/ust/agent/integration/jul/JulEnabledEventsTest.java
index 27f033e1f485f3c6cd96e0b2833f8376bcc76508..53fdafe78f8a9b878069a128a2ed20685334239e 100644 (file)
--- a/src/org/lttng/ust/agent/integration/jul/JulEnabledEventsTest.java
+++ b/src/org/lttng/ust/agent/integration/jul/JulEnabledEventsTest.java
@@ -7,11 +7,11 @@ import static org.junit.Assume.assumeTrue;
 
 import java.io.IOException;
 import java.util.List;
-import java.util.logging.Handler;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import org.junit.After;
+import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -23,6 +23,8 @@ public class JulEnabledEventsTest {
 
     private static final Domain DOMAIN = Domain.JUL;
 
+    private static final String SESSION_NAME = JulEnabledEventsTest.class.getSimpleName();
+
     private static final String EVENT_NAME_A = "EventA";
     private static final String EVENT_NAME_B = "EventAB";
     private static final String EVENT_NAME_C = "EventABC";
@@ -33,9 +35,9 @@ public class JulEnabledEventsTest {
     private Logger loggerC;
     private Logger loggerD;
 
-    private Handler handlerA;
-    private Handler handlerB;
-    private Handler handlerC;
+    private LttngLogHandler handlerA;
+    private LttngLogHandler handlerB;
+    private LttngLogHandler handlerC;
 
     @BeforeClass
     public static void classSetup() {
@@ -48,13 +50,23 @@ public class JulEnabledEventsTest {
         }
 
         boolean ret1 = LttngSessionControl.setupSession(null, DOMAIN);
-        boolean ret2 = LttngSessionControl.stopSession();
-        boolean ret3 = LttngSessionControl.destroySession();
+        boolean ret2 = LttngSessionControl.stopSession(null);
+        /* "lttng view" also tests that Babeltrace is installed and working */
+        List<String> contents = LttngSessionControl.viewSession(null);
+        boolean ret3 = LttngSessionControl.destroySession(null);
         assumeTrue(ret1 && ret2 && ret3);
+        assumeTrue(contents.isEmpty());
+    }
+
+    @AfterClass
+    public static void classCleanup() {
+        LttngSessionControl.deleteAllTracee();
     }
 
     @Before
     public void setup() throws SecurityException, IOException {
+        // TODO Wipe all existing LTTng sessions?
+
         loggerA = Logger.getLogger(EVENT_NAME_A);
         loggerB = Logger.getLogger(EVENT_NAME_B);
         loggerC = Logger.getLogger(EVENT_NAME_C);
@@ -71,11 +83,14 @@ public class JulEnabledEventsTest {
 
         loggerA.addHandler(handlerA);
         loggerB.addHandler(handlerB);
-        loggerC.addHandler(handlerB);
+        loggerC.addHandler(handlerC);
     }
 
     @After
     public void teardown() {
+        /* Just in case the test failed */
+        LttngSessionControl.tryDestroySession(SESSION_NAME);
+
         loggerA.removeHandler(handlerA);
         loggerB.removeHandler(handlerB);
         loggerC.removeHandler(handlerC);
@@ -95,24 +110,29 @@ public class JulEnabledEventsTest {
 
     /**
      * Test sending events on the Java side, but no events enabled in the
-     * tracing session. There should be nothing in the resulting trace.
+     * tracing session. There should be nothing in the resulting trace, and
+     * handlers should not have logged anything.
      */
     @Test
     public void testNoEvents() {
-        assertTrue(LttngSessionControl.setupSession(null, DOMAIN));
+        assertTrue(LttngSessionControl.setupSession(SESSION_NAME, DOMAIN));
 
         send10Events(loggerA);
         send10Events(loggerB);
         send10Events(loggerC);
         send10Events(loggerD);
 
-        assertTrue(LttngSessionControl.stopSession());
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
 
-        List<String> output = LttngSessionControl.viewSession();
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
         assertNotNull(output);
         assertTrue(output.isEmpty());
 
-        assertTrue(LttngSessionControl.destroySession());
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(0, handlerA.getEventCount());
+        assertEquals(0, handlerB.getEventCount());
+        assertEquals(0, handlerC.getEventCount());
     }
 
     /**
@@ -121,20 +141,24 @@ public class JulEnabledEventsTest {
      */
     @Test
     public void testAllEvents() {
-        assertTrue(LttngSessionControl.setupSessionAllEvents(null, DOMAIN));
+        assertTrue(LttngSessionControl.setupSessionAllEvents(SESSION_NAME, DOMAIN));
 
         send10Events(loggerA);
         send10Events(loggerB);
         send10Events(loggerC);
         send10Events(loggerD);
 
-        assertTrue(LttngSessionControl.stopSession());
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
 
-        List<String> output = LttngSessionControl.viewSession();
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
         assertNotNull(output);
-        assertEquals(20, output.size()); // loggerC has no handler attached
+        assertEquals(30, output.size()); // loggerD has no handler attached
 
-        assertTrue(LttngSessionControl.destroySession());
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(10, handlerA.getEventCount());
+        assertEquals(10, handlerB.getEventCount());
+        assertEquals(10, handlerC.getEventCount());
     }
 
     /**
@@ -143,28 +167,173 @@ public class JulEnabledEventsTest {
      */
     @Test
     public void testSomeEvents() {
-        assertTrue(LttngSessionControl.setupSession(null, DOMAIN,
-                EVENT_NAME_A, EVENT_NAME_D));
+        assertTrue(LttngSessionControl.setupSession(SESSION_NAME, DOMAIN,
+                EVENT_NAME_A, EVENT_NAME_C, EVENT_NAME_D));
+
+        send10Events(loggerA);
+        send10Events(loggerB);
+        send10Events(loggerC);
+        send10Events(loggerD);
+
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
+
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
+        assertNotNull(output);
+        assertEquals(20, output.size());
+
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(10, handlerA.getEventCount());
+        assertEquals(0, handlerB.getEventCount());
+        assertEquals(10, handlerC.getEventCount());
+    }
+
+    /**
+     * Test with all events enabled (-a), plus some other events added manually.
+     * Events should still be retained, but there should be no duplicates.
+     */
+    @Test
+    public void testAllEventsAndSome() {
+        assertTrue(LttngSessionControl.setupSessionAllEvents(SESSION_NAME, DOMAIN));
+        assertTrue(LttngSessionControl.enableEvents(SESSION_NAME, DOMAIN,
+                EVENT_NAME_A, EVENT_NAME_B));
+
+        send10Events(loggerA);
+        send10Events(loggerB);
+        send10Events(loggerC);
+        send10Events(loggerD);
+
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
+
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
+        assertNotNull(output);
+        assertEquals(30, output.size());
+
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(10, handlerA.getEventCount());
+        assertEquals(10, handlerB.getEventCount());
+        assertEquals(10, handlerC.getEventCount());
+    }
+
+    /**
+     * Same as {@link #testSomeEvents()}, but some events were enabled first,
+     * then disabled. Makes sure the enabled-event refcounting works properly.
+     */
+    @Test
+    public void testSomeEventsAfterDisabling() {
+        assertTrue(LttngSessionControl.setupSession(SESSION_NAME, DOMAIN,
+                EVENT_NAME_A, EVENT_NAME_C, EVENT_NAME_D));
+
+        assertTrue(LttngSessionControl.disableEvents(SESSION_NAME, DOMAIN,
+                EVENT_NAME_C));
+
+        send10Events(loggerA);
+        send10Events(loggerB);
+        send10Events(loggerC);
+        send10Events(loggerD);
+
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
+
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
+        assertNotNull(output);
+        assertEquals(10, output.size());
+
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(10, handlerA.getEventCount());
+        assertEquals(0, handlerB.getEventCount());
+        assertEquals(0, handlerC.getEventCount());
+    }
+
+    /**
+     * Test enabling an event prefix, which means an event name ending with a *,
+     * to match all events starting with this name.
+     */
+    @Test
+    public void testEventPrefix() {
+        assertTrue(LttngSessionControl.setupSession(SESSION_NAME, DOMAIN,
+                "EventAB*")); // should match event/loggers B and C, but not A.
+
+        send10Events(loggerA);
+        send10Events(loggerB);
+        send10Events(loggerC);
+        send10Events(loggerD);
+
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
+
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
+        assertNotNull(output);
+        assertEquals(20, output.size());
+
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(0, handlerA.getEventCount());
+        assertEquals(10, handlerB.getEventCount());
+        assertEquals(10, handlerC.getEventCount());
+    }
+
+    /**
+     * Same as {@link #testEventPrefix()}, but with multiple prefixes that
+     * overlap. There should not be any duplicate events in the trace or in the
+     * handlers.
+     */
+    @Test
+    public void testEventPrefixOverlapping() {
+        assertTrue(LttngSessionControl.setupSession(SESSION_NAME, DOMAIN,
+                "EventAB*", "EventABC*")); // should still match B and C
 
         send10Events(loggerA);
         send10Events(loggerB);
         send10Events(loggerC);
         send10Events(loggerD);
 
-        assertTrue(LttngSessionControl.stopSession());
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
 
-        List<String> output = LttngSessionControl.viewSession();
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
         assertNotNull(output);
-        assertEquals(10, output.size()); // loggerC has no handler attached
+        assertEquals(20, output.size());
+
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
+
+        assertEquals(0, handlerA.getEventCount());
+        assertEquals(10, handlerB.getEventCount());
+        assertEquals(10, handlerC.getEventCount());
+    }
+
+    /**
+     * Test with all events enabled (-a), plus an event prefix. Once again,
+     * there should be no duplicates.
+     */
+    @Test
+    public void testAllEventsAndPrefix() {
+        assertTrue(LttngSessionControl.setupSessionAllEvents(SESSION_NAME, DOMAIN));
+        assertTrue(LttngSessionControl.enableEvents(SESSION_NAME, DOMAIN,
+                "EventAB*")); // should match B and C
+
+        send10Events(loggerA);
+        send10Events(loggerB);
+        send10Events(loggerC);
+        send10Events(loggerD);
+
+        assertTrue(LttngSessionControl.stopSession(SESSION_NAME));
+
+        List<String> output = LttngSessionControl.viewSession(SESSION_NAME);
+        assertNotNull(output);
+        assertEquals(30, output.size());
+
+        assertTrue(LttngSessionControl.destroySession(SESSION_NAME));
 
-        assertTrue(LttngSessionControl.destroySession());
+        assertEquals(10, handlerA.getEventCount());
+        assertEquals(10, handlerB.getEventCount());
+        assertEquals(10, handlerC.getEventCount());
     }
 
     private static void send10Events(Logger logger) {
         String a = new String("a");
-        Object[] params = {a, new String("b"), new Object()};
+        Object[] params = { a, new String("b"), new Object() };
 
-     // Levels are FINE, FINER, FINEST, INFO, SEVERE, WARNING
+        // Levels are FINE, FINER, FINEST, INFO, SEVERE, WARNING
         logger.fine("A fine level message");
         logger.finer("A finer level message");
         logger.finest("A finest level message");