src/test/java/org/lttng/ust/agent/integration/MultiSessionTestBase.java

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