src/org/lttng/ust/agent/integration/jul/JulEnabledEventsTest.java

   1 package org.lttng.ust.agent.integration.jul;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertNotNull;
   5 import static org.junit.Assert.assertTrue;
   6 import static org.junit.Assume.assumeTrue;
   7
   8 import java.io.IOException;
   9 import java.util.List;
  10 import java.util.logging.Handler;
  11 import java.util.logging.Level;
  12 import java.util.logging.Logger;
  13
  14 import org.junit.After;
  15 import org.junit.Before;
  16 import org.junit.BeforeClass;
  17 import org.junit.Test;
  18 import org.lttng.ust.agent.jul.LttngLogHandler;
  19 import org.lttng.ust.agent.utils.LttngSessionControl;
  20 import org.lttng.ust.agent.utils.LttngSessionControl.Domain;
  21
  22 public class JulEnabledEventsTest {
  23
  24     private static final Domain DOMAIN = Domain.JUL;
  25
  26     private static final String EVENT_NAME_A = "EventA";
  27     private static final String EVENT_NAME_B = "EventAB";
  28     private static final String EVENT_NAME_C = "EventABC";
  29     private static final String EVENT_NAME_D = "EventABCD";
  30
  31     private Logger loggerA;
  32     private Logger loggerB;
  33     private Logger loggerC;
  34     private Logger loggerD;
  35
  36     private Handler handlerA;
  37     private Handler handlerB;
  38     private Handler handlerC;
  39
  40     @BeforeClass
  41     public static void classSetup() {
  42         /* Skip tests if we can't find the JNI library or lttng-tools */
  43         try {
  44             LttngLogHandler testHandler = new LttngLogHandler();
  45             testHandler.close();
  46         } catch (SecurityException | IOException e) {
  47             assumeTrue(false);
  48         }
  49
  50         boolean ret1 = LttngSessionControl.setupSession(null, DOMAIN);
  51         boolean ret2 = LttngSessionControl.stopSession();
  52         boolean ret3 = LttngSessionControl.destroySession();
  53         assumeTrue(ret1 && ret2 && ret3);
  54     }
  55
  56     @Before
  57     public void setup() throws SecurityException, IOException {
  58         loggerA = Logger.getLogger(EVENT_NAME_A);
  59         loggerB = Logger.getLogger(EVENT_NAME_B);
  60         loggerC = Logger.getLogger(EVENT_NAME_C);
  61         loggerD = Logger.getLogger(EVENT_NAME_D);
  62
  63         loggerA.setLevel(Level.ALL);
  64         loggerB.setLevel(Level.ALL);
  65         loggerC.setLevel(Level.ALL);
  66         loggerD.setLevel(Level.ALL);
  67
  68         handlerA = new LttngLogHandler();
  69         handlerB = new LttngLogHandler();
  70         handlerC = new LttngLogHandler();
  71
  72         loggerA.addHandler(handlerA);
  73         loggerB.addHandler(handlerB);
  74         loggerC.addHandler(handlerB);
  75     }
  76
  77     @After
  78     public void teardown() {
  79         loggerA.removeHandler(handlerA);
  80         loggerB.removeHandler(handlerB);
  81         loggerC.removeHandler(handlerC);
  82
  83         handlerA.close();
  84         handlerB.close();
  85         handlerC.close();
  86
  87         loggerA = null;
  88         loggerB = null;
  89         loggerC = null;
  90         loggerD = null;
  91         handlerA = null;
  92         handlerB = null;
  93         handlerC = null;
  94     }
  95
  96     /**
  97      * Test sending events on the Java side, but no events enabled in the
  98      * tracing session. There should be nothing in the resulting trace.
  99      */
 100     @Test
 101     public void testNoEvents() {
 102         assertTrue(LttngSessionControl.setupSession(null, DOMAIN));
 103
 104         send10Events(loggerA);
 105         send10Events(loggerB);
 106         send10Events(loggerC);
 107         send10Events(loggerD);
 108
 109         assertTrue(LttngSessionControl.stopSession());
 110
 111         List<String> output = LttngSessionControl.viewSession();
 112         assertNotNull(output);
 113         assertTrue(output.isEmpty());
 114
 115         assertTrue(LttngSessionControl.destroySession());
 116     }
 117
 118     /**
 119      * Test sending events on the Java side, and all events enabled in the
 120      * tracing session. All handlers should have sent their events.
 121      */
 122     @Test
 123     public void testAllEvents() {
 124         assertTrue(LttngSessionControl.setupSessionAllEvents(null, DOMAIN));
 125
 126         send10Events(loggerA);
 127         send10Events(loggerB);
 128         send10Events(loggerC);
 129         send10Events(loggerD);
 130
 131         assertTrue(LttngSessionControl.stopSession());
 132
 133         List<String> output = LttngSessionControl.viewSession();
 134         assertNotNull(output);
 135         assertEquals(20, output.size()); // loggerC has no handler attached
 136
 137         assertTrue(LttngSessionControl.destroySession());
 138     }
 139
 140     /**
 141      * Test sending events on the Java side, with only some of them enabled in
 142      * the tracing session. Only the subset that is enabled should be received.
 143      */
 144     @Test
 145     public void testSomeEvents() {
 146         assertTrue(LttngSessionControl.setupSession(null, DOMAIN,
 147                 EVENT_NAME_A, EVENT_NAME_D));
 148
 149         send10Events(loggerA);
 150         send10Events(loggerB);
 151         send10Events(loggerC);
 152         send10Events(loggerD);
 153
 154         assertTrue(LttngSessionControl.stopSession());
 155
 156         List<String> output = LttngSessionControl.viewSession();
 157         assertNotNull(output);
 158         assertEquals(10, output.size()); // loggerC has no handler attached
 159
 160         assertTrue(LttngSessionControl.destroySession());
 161     }
 162
 163     private static void send10Events(Logger logger) {
 164         String a = new String("a");
 165         Object[] params = {a, new String("b"), new Object()};
 166
 167      // Levels are FINE, FINER, FINEST, INFO, SEVERE, WARNING
 168         logger.fine("A fine level message");
 169         logger.finer("A finer level message");
 170         logger.finest("A finest level message");
 171         logger.info("A info level message");
 172         logger.severe("A severe level message");
 173         logger.warning("A warning level message");
 174         logger.warning("Another warning level message");
 175         logger.log(Level.WARNING, "A warning message using Logger.log()");
 176         logger.log(Level.INFO, "A message with one parameter", a);
 177         logger.log(Level.INFO, "A message with parameters", params);
 178     }
 179
 180 }