src/org/lttng/ust/agent/integration/common/MultiSessionTest.java

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