lttng/org.eclipse.tracecompass.lttng2.control.ui.tests/src/org/eclipse/tracecompass/lttng2/control/ui/tests/service/LTTngControlServiceTest.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 2015 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Bernd Hufmann - Initial API and implementation
  11  *   Alexandre Montplaisir - Port to JUnit4
  12  *   Marc-Andre Laperle - Support for creating a live session
  13  **********************************************************************/
  14
  15 package org.eclipse.tracecompass.lttng2.control.ui.tests.service;
  16
  17 import static org.junit.Assert.assertEquals;
  18 import static org.junit.Assert.assertFalse;
  19 import static org.junit.Assert.assertNotNull;
  20 import static org.junit.Assert.assertTrue;
  21 import static org.junit.Assert.fail;
  22
  23 import java.io.File;
  24 import java.net.URL;
  25 import java.util.ArrayList;
  26 import java.util.HashSet;
  27 import java.util.List;
  28 import java.util.Set;
  29
  30 import org.eclipse.core.commands.ExecutionException;
  31 import org.eclipse.core.runtime.FileLocator;
  32 import org.eclipse.core.runtime.NullProgressMonitor;
  33 import org.eclipse.core.runtime.Path;
  34 import org.eclipse.jdt.annotation.NonNull;
  35 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IBaseEventInfo;
  36 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IChannelInfo;
  37 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IDomainInfo;
  38 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IEventInfo;
  39 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IFieldInfo;
  40 import org.eclipse.tracecompass.internal.lttng2.control.core.model.ISessionInfo;
  41 import org.eclipse.tracecompass.internal.lttng2.control.core.model.ISnapshotInfo;
  42 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IUstProviderInfo;
  43 import org.eclipse.tracecompass.internal.lttng2.control.core.model.LogLevelType;
  44 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceChannelOutputType;
  45 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceEnablement;
  46 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceEventType;
  47 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceLogLevel;
  48 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceSessionState;
  49 import org.eclipse.tracecompass.internal.lttng2.control.core.model.impl.BufferType;
  50 import org.eclipse.tracecompass.internal.lttng2.control.core.model.impl.ChannelInfo;
  51 import org.eclipse.tracecompass.internal.lttng2.control.core.model.impl.SessionInfo;
  52 import org.eclipse.tracecompass.internal.lttng2.control.stubs.shells.LTTngToolsFileShell;
  53 import org.eclipse.tracecompass.internal.lttng2.control.ui.Activator;
  54 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.logging.ControlCommandLogger;
  55 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.preferences.ControlPreferences;
  56 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.service.ILttngControlService;
  57 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.service.LTTngControlService;
  58 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.service.LTTngControlServiceFactory;
  59 import org.junit.After;
  60 import org.junit.Before;
  61 import org.junit.Test;
  62 import org.osgi.framework.FrameworkUtil;
  63
  64 /**
  65  * The class <code>LTTngControlServiceTest</code> contains test for the class
  66  * <code>{@link  LTTngControlService}</code>.
  67  */
  68 @SuppressWarnings("javadoc")
  69 public class LTTngControlServiceTest {
  70
  71     private static final String DIRECTORY   = "testfiles";
  72     private static final String TEST_STREAM = "LTTngServiceTest.cfg";
  73
  74     private static final String SCEN_LTTNG_NOT_INSTALLED = "LttngNotInstalled";
  75     private static final String SCEN_LTTNG_VERSION = "LttngVersion";
  76     private static final String SCEN_LTTNG_VERSION_WITH_PROMPT = "LttngVersionWithPrompt";
  77     private static final String SCEN_LTTNG_UNSUPPORTED_VERSION = "LttngUnsupportedVersion";
  78     private static final String SCEN_LTTNG_NO_VERSION = "LttngNoVersion";
  79     private static final String SCEN_LTTNG_COMPILED_VERSION = "LttngVersionCompiled";
  80     private static final String SCEN_NO_SESSION_AVAILABLE = "NoSessionAvailable";
  81     private static final String SCEN_GET_SESSION_NAMES1 = "GetSessionNames1";
  82     private static final String SCEN_GET_SESSION_WITH_GROUP = "GetSessionWithTracingGroup";
  83     private static final String SCEN_GET_SESSION_NAME_NOT_EXIST = "GetSessionNameNotExist";
  84     private static final String SCEN_GET_SESSION_NAME_NOT_EXIST_VERBOSE = "GetSessionNameNotExistVerbose";
  85     protected static final String SCEN_GET_SESSION_GARBAGE_OUT = "GetSessionGarbageOut";
  86     private static final String SCEN_GET_SESSION1 = "GetSession1";
  87     private static final String SCEN_GET_SESSION_WITH_LIVE = "GetSessionWithLiveInterval";
  88     private static final String SCEN_GET_KERNEL_PROVIDER1 = "GetKernelProvider1";
  89     private static final String SCEN_LIST_WITH_NO_KERNEL1 = "ListWithNoKernel1";
  90     private static final String SCEN_LIST_WITH_NO_KERNEL2 = "ListWithNoKernel2";
  91     private static final String SCEN_LIST_WITH_NO_KERNEL_VERBOSE = "ListWithNoKernelVerbose";
  92     private static final String SCEN_GET_UST_PROVIDER1 = "GetUstProvider1";
  93     private static final String SCEN_GET_UST_PROVIDER2 = "GetUstProvider2";
  94     private static final String SCEN_GET_UST_PROVIDER3 = "GetUstProvider3";
  95     private static final String SCEN_LIST_WITH_NO_UST1 = "ListWithNoUst1";
  96     private static final String SCEN_LIST_WITH_NO_UST2 = "ListWithNoUst2";
  97     private static final String SCEN_LIST_WITH_NO_UST3 = "ListWithNoUst3";
  98     private static final String SCEN_LIST_WITH_NO_UST_VERBOSE = "ListWithNoUstVerbose";
  99     private static final String SCEN_CREATE_SESSION1 = "CreateSession1";
 100     private static final String SCEN_CREATE_SESSION_WITH_PROMPT = "CreateSessionWithPrompt";
 101     private static final String SCEN_CREATE_SESSION_VARIANTS = "CreateSessionVariants";
 102     private static final String SCEN_DESTROY_SESSION1 = "DestroySession1";
 103     private static final String SCEN_DESTROY_SESSION_VERBOSE = "DestroySessionVerbose";
 104     private static final String SCEN_CHANNEL_HANDLING = "ChannelHandling";
 105     private static final String SCEN_EVENT_HANDLING = "EventHandling";
 106     private static final String SCEN_CONTEXT_HANDLING = "ContextHandling";
 107     private static final String SCEN_CONTEXT_ERROR_HANDLING = "ContextErrorHandling";
 108     private static final String SCEN_CALIBRATE_HANDLING = "CalibrateHandling";
 109     private static final String SCEN_CREATE_SESSION_2_1 = "CreateSessionLttng2.1";
 110     private static final String SCEN_CREATE_SESSION_VERBOSE_2_1 = "CreateSessionLttngVerbose2.1";
 111     private static final String SCEN_CREATE_SNAPSHOT_SESSION = "CreateSessionSnapshot";
 112     private static final String SCEN_CREATE_SNAPSHOT_SESSION_2_5 = "CreateSessionSnapshot2.5";
 113     private static final String SCEN_CREATE_STREAMED_SNAPSHOT_SESSION = "CreateSessionStreamedSnapshot";
 114     private static final String SCEN_CREATE_SNAPSHOT_SESSION_ERRORS = "CreateSessionSnapshotErrors";
 115     protected static final String SCEN_CREATE_LIVE_SESSION = "CreateSessionLive";
 116     private static final String SCEN_CREATE_LIVE_SESSION_ERRORS = "CreateSessionLiveErrors";
 117
 118
 119     // ------------------------------------------------------------------------
 120     // Test data
 121     // ------------------------------------------------------------------------
 122     private String fTestfile;
 123     protected final @NonNull LTTngToolsFileShell fShell = new LTTngToolsFileShell();
 124     protected ILttngControlService fService;
 125
 126     // ------------------------------------------------------------------------
 127     // Housekeeping
 128     // ------------------------------------------------------------------------
 129
 130     /**
 131      * Perform pre-test initialization.
 132      *
 133      * @throws Exception
 134      *             if the initialization fails for some reason
 135      */
 136     @Before
 137     public void setUp() throws Exception {
 138         URL location = FileLocator.find(FrameworkUtil.getBundle(this.getClass()), new Path(getTestDirectory() + File.separator + getTestStream()), null);
 139         File testfile = new File(FileLocator.toFileURL(location).toURI());
 140         fTestfile = testfile.getAbsolutePath();
 141         fShell.loadScenarioFile(fTestfile);
 142         fService = getControlService();
 143         if (fService == null) {
 144             throw new Exception("Unable to obtain a valid ControlService");
 145         }
 146
 147         ControlPreferences.getInstance().init(Activator.getDefault().getPreferenceStore());
 148     }
 149
 150     /**
 151      * @return the string of the test directory to use
 152      */
 153     protected String getTestDirectory() {
 154         return DIRECTORY;
 155     }
 156
 157     /**
 158      * @return the LttngCon
 159      */
 160     protected ILttngControlService getControlService() {
 161         return new LTTngControlService(fShell);
 162     }
 163
 164     /**
 165      * @return the shell implementation
 166      */
 167     public @NonNull LTTngToolsFileShell getShell() {
 168         return fShell;
 169     }
 170
 171     /**
 172      * @return
 173      */
 174     protected String getTestStream() {
 175         return TEST_STREAM;
 176     }
 177
 178     @After
 179     public void tearDown() {
 180         disableVerbose();
 181         ControlPreferences.getInstance().dispose();
 182     }
 183
 184     // ------------------------------------------------------------------------
 185     // Test Cases
 186     // ------------------------------------------------------------------------
 187
 188     @Test
 189     public void testVersion() {
 190         try {
 191             fShell.setScenario(SCEN_LTTNG_VERSION);
 192             ILttngControlService service = LTTngControlServiceFactory.getLttngControlService(fShell);
 193             assertNotNull(service);
 194             assertEquals("2.1.0", service.getVersionString());
 195         } catch (ExecutionException e) {
 196             fail("Exeption thrown " + e);
 197         }
 198     }
 199
 200     @Test
 201     public void testVersionWithPrompt() {
 202         try {
 203             fShell.setScenario(SCEN_LTTNG_VERSION_WITH_PROMPT);
 204             ILttngControlService service = LTTngControlServiceFactory.getLttngControlService(fShell);
 205             assertNotNull(service);
 206             assertEquals("2.0.0", service.getVersionString());
 207         } catch (ExecutionException e) {
 208             fail("Exeption thrown " + e);
 209         }
 210     }
 211
 212     @Test(expected=ExecutionException.class)
 213     public void testUnsupportedVersion() throws ExecutionException {
 214         fShell.setScenario(SCEN_LTTNG_UNSUPPORTED_VERSION);
 215         LTTngControlServiceFactory.getLttngControlService(fShell);
 216     }
 217
 218     @Test
 219     public void testNoVersion() {
 220         try {
 221             fShell.setScenario(SCEN_LTTNG_NO_VERSION);
 222             LTTngControlServiceFactory.getLttngControlService(fShell);
 223             fail("No exeption thrown");
 224         } catch (ExecutionException e) {
 225             // success
 226         }
 227     }
 228
 229     @Test
 230     public void testVersionCompiled() {
 231         try {
 232             fShell.setScenario(SCEN_LTTNG_COMPILED_VERSION);
 233             ILttngControlService service = LTTngControlServiceFactory.getLttngControlService(fShell);
 234             assertNotNull(service);
 235             assertEquals("2.5.0", service.getVersionString());
 236         } catch (ExecutionException e) {
 237             fail("Exeption thrown " + e);
 238         }
 239     }
 240
 241
 242     @Test
 243     public void testLttngNotInstalled() {
 244         try {
 245             fShell.setScenario(SCEN_LTTNG_NOT_INSTALLED);
 246             fService.getSessionNames(new NullProgressMonitor());
 247             fail("No exeption thrown");
 248         } catch (ExecutionException e) {
 249          // success
 250         }
 251     }
 252
 253     @Test
 254     public void testGetSessionNames1() {
 255         try {
 256             fShell.setScenario(SCEN_NO_SESSION_AVAILABLE);
 257             List<String> result = fService.getSessionNames(new NullProgressMonitor());
 258
 259             assertNotNull(result);
 260             assertEquals(0, result.size());
 261
 262         } catch (ExecutionException e) {
 263             fail(e.toString());
 264         }
 265     }
 266
 267     @Test
 268     public void testGetSessionNames2() {
 269         try {
 270             fShell.setScenario(SCEN_GET_SESSION_NAMES1);
 271             List<String> result = fService.getSessionNames(new NullProgressMonitor());
 272
 273             assertNotNull(result);
 274             assertEquals(2, result.size());
 275             assertEquals("mysession1", result.get(0));
 276             assertEquals("mysession", result.get(1));
 277
 278         } catch (ExecutionException e) {
 279             fail(e.toString());
 280         }
 281     }
 282
 283     @Test
 284     public void testGetSessionNamesWithTracingGroup() {
 285         try {
 286             fShell.setScenario(SCEN_GET_SESSION_WITH_GROUP);
 287             ControlPreferences.getInstance().getPreferenceStore().setValue(
 288                     ControlPreferences.TRACE_CONTROL_TRACING_GROUP_PREF, "group");
 289
 290             List<String> result = fService.getSessionNames(new NullProgressMonitor());
 291
 292             assertNotNull(result);
 293             assertEquals(2, result.size());
 294             assertEquals("mysession1", result.get(0));
 295             assertEquals("mysession", result.get(1));
 296
 297             ControlCommandLogger.init(ControlPreferences.getInstance().getLogfilePath(), false);
 298             ControlPreferences.getInstance().getPreferenceStore().setValue(
 299                     ControlPreferences.TRACE_CONTROL_TRACING_GROUP_PREF, ControlPreferences.TRACE_CONTROL_DEFAULT_TRACING_GROUP);
 300
 301
 302         } catch (ExecutionException e) {
 303             fail(e.toString());
 304         }
 305     }
 306
 307
 308     @Test
 309     public void testGetSessionNotExist() {
 310         try {
 311             fShell.setScenario(SCEN_GET_SESSION_NAME_NOT_EXIST);
 312             fService.getSessionNames(new NullProgressMonitor());
 313             fail("No exeption thrown");
 314
 315         } catch (ExecutionException e) {
 316             // success
 317         }
 318     }
 319
 320     @Test
 321     public void testGetSessionNotExistVerbose() {
 322         try {
 323             enableVerbose();
 324             fShell.setScenario(SCEN_GET_SESSION_NAME_NOT_EXIST_VERBOSE);
 325             fService.getSessionNames(new NullProgressMonitor());
 326             fail("No exeption thrown");
 327
 328         } catch (ExecutionException e) {
 329             // success
 330         } finally {
 331             disableVerbose();
 332         }
 333     }
 334
 335     @Test
 336     public void testGetSessionNameGarbage() {
 337         try {
 338             fShell.setScenario(SCEN_GET_SESSION_GARBAGE_OUT);
 339             List<String> result = fService.getSessionNames(new NullProgressMonitor());
 340
 341             assertNotNull(result);
 342             assertEquals(0, result.size());
 343
 344         } catch (ExecutionException e) {
 345             fail(e.toString());
 346         }
 347     }
 348
 349     @Test
 350     public void testGetSession1() {
 351         try {
 352             fShell.setScenario(SCEN_GET_SESSION1);
 353             ISessionInfo session = fService.getSession("mysession", new NullProgressMonitor());
 354
 355             // Verify Session
 356             assertNotNull(session);
 357             assertEquals("mysession", session.getName());
 358             assertEquals("/home/user/lttng-traces/mysession-20120129-084256", session.getSessionPath());
 359             assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
 360
 361             IDomainInfo[] domains = session.getDomains();
 362             assertNotNull(domains);
 363             assertEquals(2, domains.length);
 364
 365             // Verify Kernel domain
 366             assertEquals("Kernel", domains[0].getName());
 367             IChannelInfo[] channels =  domains[0].getChannels();
 368             assertNotNull(channels);
 369             assertEquals(2, channels.length);
 370
 371             // Verify Kernel's channel0
 372             assertEquals("channel0", channels[0].getName());
 373             assertEquals(4, channels[0].getNumberOfSubBuffers());
 374             assertEquals("splice()", channels[0].getOutputType().getInName());
 375             assertEquals(TraceChannelOutputType.SPLICE, channels[0].getOutputType());
 376             assertEquals(false, channels[0].isOverwriteMode());
 377             assertEquals(200, channels[0].getReadTimer());
 378             assertEquals(TraceEnablement.ENABLED, channels[0].getState());
 379             assertEquals(262144, channels[0].getSubBufferSize());
 380             assertEquals(0, channels[0].getSwitchTimer());
 381
 382             // Verify event info
 383             IEventInfo[] channel0Events = channels[0].getEvents();
 384             assertNotNull(channel0Events);
 385             assertEquals(2, channel0Events.length);
 386             assertEquals("block_rq_remap", channel0Events[0].getName());
 387             assertEquals(TraceLogLevel.TRACE_EMERG, channel0Events[0].getLogLevel());
 388             assertEquals(TraceEventType.TRACEPOINT, channel0Events[0].getEventType());
 389             assertEquals(TraceEnablement.ENABLED, channel0Events[0].getState());
 390
 391             assertEquals("block_bio_remap", channel0Events[1].getName());
 392             assertEquals(TraceLogLevel.TRACE_EMERG, channel0Events[1].getLogLevel());
 393             assertEquals(TraceEventType.TRACEPOINT, channel0Events[1].getEventType());
 394             assertEquals(TraceEnablement.DISABLED, channel0Events[1].getState());
 395
 396             // Verify Kernel's channel1
 397             assertEquals("channel1", channels[1].getName());
 398             assertEquals(4, channels[1].getNumberOfSubBuffers());
 399             assertEquals("splice()", channels[1].getOutputType().getInName());
 400             assertEquals(TraceChannelOutputType.SPLICE, channels[1].getOutputType());
 401             assertEquals(true, channels[1].isOverwriteMode());
 402             assertEquals(400, channels[1].getReadTimer());
 403             assertEquals(TraceEnablement.DISABLED, channels[1].getState());
 404             assertEquals(524288, channels[1].getSubBufferSize());
 405             assertEquals(100, channels[1].getSwitchTimer());
 406
 407             // Verify event info
 408             IEventInfo[] channel1Events = channels[1].getEvents();
 409             assertEquals(0, channel1Events.length);
 410
 411             // Verify domain UST global
 412             assertEquals("UST global", domains[1].getName());
 413
 414             IChannelInfo[] ustChannels =  domains[1].getChannels();
 415
 416             // Verify UST global's mychannel1
 417             assertEquals("mychannel1", ustChannels[0].getName());
 418             assertEquals(8, ustChannels[0].getNumberOfSubBuffers());
 419             assertEquals("mmap()", ustChannels[0].getOutputType().getInName());
 420             assertEquals(TraceChannelOutputType.MMAP, ustChannels[0].getOutputType());
 421             assertEquals(true, ustChannels[0].isOverwriteMode());
 422             assertEquals(100, ustChannels[0].getReadTimer());
 423             assertEquals(TraceEnablement.DISABLED, ustChannels[0].getState());
 424             assertEquals(8192, ustChannels[0].getSubBufferSize());
 425             assertEquals(200, ustChannels[0].getSwitchTimer());
 426
 427             // Verify event info
 428             IEventInfo[] ustEvents = ustChannels[0].getEvents();
 429             assertEquals(0, ustEvents.length);
 430
 431             // Verify UST global's channel0
 432             assertEquals("channel0", ustChannels[1].getName());
 433             assertEquals(4, ustChannels[1].getNumberOfSubBuffers());
 434             assertEquals("mmap()", ustChannels[1].getOutputType().getInName());
 435             assertEquals(TraceChannelOutputType.MMAP, ustChannels[1].getOutputType());
 436             assertEquals(false, ustChannels[1].isOverwriteMode());
 437             assertEquals(200, ustChannels[1].getReadTimer());
 438             assertEquals(TraceEnablement.ENABLED, ustChannels[1].getState());
 439             assertEquals(4096, ustChannels[1].getSubBufferSize());
 440             assertEquals(0, ustChannels[1].getSwitchTimer());
 441
 442             // Verify event info
 443             ustEvents = ustChannels[1].getEvents();
 444             assertEquals(2, ustEvents.length);
 445
 446             assertEquals("ust_tests_hello:tptest_sighandler", ustEvents[0].getName());
 447             assertEquals(TraceLogLevel.TRACE_DEBUG_LINE, ustEvents[0].getLogLevel());
 448             assertEquals(TraceEventType.TRACEPOINT, ustEvents[0].getEventType());
 449             assertEquals(TraceEnablement.DISABLED, ustEvents[0].getState());
 450
 451             assertEquals("*", ustEvents[1].getName());
 452             assertEquals(getAllEventTraceLogLevel(), ustEvents[1].getLogLevel());
 453             assertEquals(TraceEventType.TRACEPOINT, ustEvents[1].getEventType());
 454             assertEquals(TraceEnablement.ENABLED, ustEvents[1].getState());
 455
 456             // next session (no detailed information available)
 457             session = fService.getSession("mysession1", new NullProgressMonitor());
 458             assertNotNull(session);
 459             assertEquals("mysession1", session.getName());
 460             assertEquals("/home/user/lttng-traces/mysession1-20120203-133225", session.getSessionPath());
 461             assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
 462
 463             domains = session.getDomains();
 464             assertNotNull(domains);
 465             assertEquals(0, domains.length);
 466         } catch (ExecutionException e) {
 467             fail(e.toString());
 468         }
 469     }
 470
 471     @Test
 472     public void testGetSessionWithLive() {
 473         try {
 474             fShell.setScenario(SCEN_GET_SESSION_WITH_LIVE);
 475
 476             // Verify Session (snapshot session, non-live)
 477             ISessionInfo session = fService.getSession("mysession", new NullProgressMonitor());
 478             assertNotNull(session);
 479             assertEquals("mysession", session.getName());
 480             assertEquals("/home/user/lttng-traces/mysession-20120129-084256", session.getSessionPath());
 481             assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
 482             assertFalse(session.isLive());
 483
 484             // Verify Session (regular session, non-live)
 485             session = fService.getSession("mysession1", new NullProgressMonitor());
 486             assertNotNull(session);
 487             assertEquals("mysession1", session.getName());
 488             assertEquals("/home/user/lttng-traces/mysession1-20120129-084256", session.getSessionPath());
 489             assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
 490             assertFalse(session.isLive());
 491
 492             // Verify Session (regular session, live)
 493             session = fService.getSession("mysession2", new NullProgressMonitor());
 494             assertNotNull(session);
 495             assertEquals("mysession2", session.getName());
 496             assertEquals("tcp4://172.0.0.1:5342/ [data: 5343]", session.getSessionPath());
 497             assertEquals("net://127.0.0.1", session.getLiveUrl());
 498             assertEquals(Integer.valueOf(5344), session.getLivePort());
 499             assertEquals(1000000, session.getLiveDelay());
 500             assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
 501             assertTrue(session.isLive());
 502
 503         } catch (ExecutionException e) {
 504             fail(e.toString());
 505         }
 506     }
 507
 508     /**
 509      * @return
 510      */
 511     protected TraceLogLevel getAllEventTraceLogLevel() {
 512         return TraceLogLevel.LEVEL_UNKNOWN;
 513     }
 514
 515     public void testGetKernelProvider() {
 516         try {
 517             fShell.setScenario(SCEN_GET_KERNEL_PROVIDER1);
 518             List<IBaseEventInfo> events = fService.getKernelProvider(new NullProgressMonitor());
 519
 520             // Verify event info
 521             assertNotNull(events);
 522             assertEquals(3, events.size());
 523
 524             IBaseEventInfo baseEventInfo = events.get(0);
 525             assertNotNull(baseEventInfo);
 526             assertEquals("sched_kthread_stop", baseEventInfo.getName());
 527             assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 528             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 529
 530             baseEventInfo = events.get(1);
 531             assertEquals("sched_kthread_stop_ret", baseEventInfo.getName());
 532             assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 533             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 534
 535             baseEventInfo = events.get(2);
 536             assertEquals("sched_wakeup_new", baseEventInfo.getName());
 537             assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 538             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 539
 540         } catch (ExecutionException e) {
 541             fail(e.toString());
 542         }
 543     }
 544
 545     @Test
 546     public void testGetKernelProviderNoKernel1() {
 547         try {
 548             fShell.setScenario(SCEN_LIST_WITH_NO_KERNEL1);
 549             List<IBaseEventInfo> events = fService.getKernelProvider(new NullProgressMonitor());
 550
 551             // Verify event info
 552             assertNotNull(events);
 553             assertEquals(0, events.size());
 554
 555         } catch (ExecutionException e) {
 556             fail(e.toString());
 557         }
 558     }
 559
 560     @Test
 561     public void testGetKernelProviderNoKernel2() {
 562         try {
 563             fShell.setScenario(SCEN_LIST_WITH_NO_KERNEL2);
 564             List<IBaseEventInfo> events = fService.getKernelProvider(new NullProgressMonitor());
 565
 566             // Verify event info
 567             assertNotNull(events);
 568             assertEquals(0, events.size());
 569
 570         } catch (ExecutionException e) {
 571             fail(e.toString());
 572         }
 573     }
 574
 575     @Test
 576     public void testGetKernelProviderNoKernelVerbose() {
 577         try {
 578             enableVerbose();
 579             fShell.setScenario(SCEN_LIST_WITH_NO_KERNEL_VERBOSE);
 580             List<IBaseEventInfo> events = fService.getKernelProvider(new NullProgressMonitor());
 581
 582             // Verify event info
 583             assertNotNull(events);
 584             assertEquals(0, events.size());
 585
 586         } catch (ExecutionException e) {
 587             fail(e.toString());
 588         } finally {
 589             disableVerbose();
 590         }
 591     }
 592
 593     @Test
 594     public void testGetUstProvider() {
 595         try {
 596             fShell.setScenario(SCEN_GET_UST_PROVIDER1);
 597             List<IUstProviderInfo> providers = fService.getUstProvider();
 598
 599             // Check all providers
 600             assertNotNull(providers);
 601             assertEquals(2, providers.size());
 602
 603             //Verify first provider
 604             assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", providers.get(0).getName());
 605             assertEquals(9379, providers.get(0).getPid());
 606
 607             // Verify event info
 608             IBaseEventInfo[] events = providers.get(0).getEvents();
 609             assertNotNull(events);
 610             assertEquals(2, events.length);
 611
 612             IBaseEventInfo baseEventInfo = events[0];
 613             assertNotNull(baseEventInfo);
 614             assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
 615             assertEquals(TraceLogLevel.TRACE_DEBUG_MODULE, baseEventInfo.getLogLevel());
 616             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 617
 618             baseEventInfo = events[1];
 619             assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
 620             assertEquals(TraceLogLevel.TRACE_INFO, baseEventInfo.getLogLevel());
 621             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 622
 623             //Verify second provider
 624             assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", providers.get(1).getName());
 625             assertEquals(4852, providers.get(1).getPid());
 626
 627             // Verify event info
 628             events = providers.get(1).getEvents();
 629             assertNotNull(events);
 630             assertEquals(2, events.length);
 631
 632             baseEventInfo = events[0];
 633             assertNotNull(baseEventInfo);
 634             assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
 635             assertEquals(TraceLogLevel.TRACE_WARNING, baseEventInfo.getLogLevel());
 636             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 637
 638             baseEventInfo = events[1];
 639             assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
 640             assertEquals(TraceLogLevel.TRACE_DEBUG_FUNCTION, baseEventInfo.getLogLevel());
 641             assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 642
 643         } catch (ExecutionException e) {
 644             fail(e.toString());
 645         }
 646     }
 647
 648     @Test
 649     public void testUstProvider2() {
 650         try {
 651             fShell.setScenario(SCEN_GET_UST_PROVIDER2);
 652             List<IUstProviderInfo> providers = fService.getUstProvider();
 653
 654             assertNotNull(providers);
 655             assertEquals(0, providers.size());
 656
 657         } catch (ExecutionException e) {
 658             fail(e.toString());
 659         }
 660     }
 661
 662     @Test
 663     public void testGetUstProvider3() {
 664         try {
 665             fShell.setScenario(SCEN_GET_UST_PROVIDER3);
 666             // Set version
 667             ((LTTngControlService)fService).setVersion("2.1.0");
 668             List<IUstProviderInfo> providers = fService.getUstProvider();
 669
 670             // Check all providers
 671             assertNotNull(providers);
 672             assertEquals(2, providers.size());
 673
 674             //Verify first provider
 675             assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", providers.get(0).getName());
 676             assertEquals(9379, providers.get(0).getPid());
 677
 678             // Verify event info
 679             IBaseEventInfo[] events = providers.get(0).getEvents();
 680             assertNotNull(events);
 681             assertEquals(2, events.length);
 682
 683             IBaseEventInfo baseEventInfo = events[0];
 684             assertNotNull(baseEventInfo);
 685             IFieldInfo[] fields = baseEventInfo.getFields();
 686             assertNotNull(fields);
 687             assertEquals(0, fields.length);
 688
 689             baseEventInfo = events[1];
 690             fields = baseEventInfo.getFields();
 691             assertNotNull(fields);
 692             assertEquals(3, fields.length);
 693             assertEquals("doublefield", fields[0].getName());
 694             assertEquals("float", fields[0].getFieldType());
 695
 696             assertEquals("floatfield", fields[1].getName());
 697             assertEquals("float", fields[1].getFieldType());
 698
 699             assertEquals("stringfield", fields[2].getName());
 700             assertEquals("string", fields[2].getFieldType());
 701
 702             //Verify second provider
 703             assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello", providers.get(1).getName());
 704             assertEquals(4852, providers.get(1).getPid());
 705
 706             // Verify event info
 707             events = providers.get(1).getEvents();
 708             assertNotNull(events);
 709             assertEquals(2, events.length);
 710
 711             baseEventInfo = events[0];
 712             assertNotNull(baseEventInfo);
 713             fields = baseEventInfo.getFields();
 714             assertNotNull(fields);
 715             assertEquals(0, fields.length);
 716
 717             baseEventInfo = events[1];
 718             fields = baseEventInfo.getFields();
 719             assertNotNull(fields);
 720             assertEquals(3, fields.length);
 721
 722             assertEquals("doublefield", fields[0].getName());
 723             assertEquals("float", fields[0].getFieldType());
 724
 725             assertEquals("floatfield", fields[1].getName());
 726             assertEquals("float", fields[1].getFieldType());
 727
 728             assertEquals("stringfield", fields[2].getName());
 729             assertEquals("string", fields[2].getFieldType());
 730
 731             // Reset version
 732             ((LTTngControlService)fService).setVersion("2.0.0");
 733
 734         } catch (ExecutionException e) {
 735             fail(e.toString());
 736         }
 737     }
 738
 739
 740     @Test
 741     public void testGetKernelProviderNoUst1() {
 742         try {
 743             fShell.setScenario(SCEN_LIST_WITH_NO_UST1);
 744             List<IUstProviderInfo> providerList = fService.getUstProvider(new NullProgressMonitor());
 745
 746             // Verify Provider info
 747             assertNotNull(providerList);
 748             assertEquals(0, providerList.size());
 749
 750         } catch (ExecutionException e) {
 751             fail(e.toString());
 752         }
 753     }
 754
 755
 756     @Test
 757     public void testGetKernelProviderNoUst2() {
 758         try {
 759             // Set version
 760             ((LTTngControlService)fService).setVersion("2.1.0");
 761
 762             fShell.setScenario(SCEN_LIST_WITH_NO_UST2);
 763             List<IUstProviderInfo> providerList = fService.getUstProvider(new NullProgressMonitor());
 764
 765             // Verify Provider info
 766             assertNotNull(providerList);
 767             assertEquals(0, providerList.size());
 768
 769             // Reset version
 770             ((LTTngControlService)fService).setVersion("2.0.0");
 771
 772         } catch (ExecutionException e) {
 773             fail(e.toString());
 774         }
 775     }
 776
 777     @Test
 778     public void testGetKernelProviderNoUst3() {
 779         try {
 780
 781             // Set version
 782             ((LTTngControlService)fService).setVersion("2.1.0");
 783
 784             fShell.setScenario(SCEN_LIST_WITH_NO_UST3);
 785             List<IUstProviderInfo> providerList = fService.getUstProvider(new NullProgressMonitor());
 786
 787             // Verify provider info
 788             assertNotNull(providerList);
 789             assertEquals(0, providerList.size());
 790
 791             // Reset version
 792             ((LTTngControlService)fService).setVersion("2.0.0");
 793
 794         } catch (ExecutionException e) {
 795             fail(e.toString());
 796         }
 797     }
 798
 799     @Test
 800     public void testGetKernelProviderNoUstVerbose() {
 801         try {
 802             enableVerbose();
 803
 804             // Set version
 805             ((LTTngControlService)fService).setVersion("2.1.0");
 806
 807             fShell.setScenario(SCEN_LIST_WITH_NO_UST_VERBOSE);
 808             List<IUstProviderInfo> providerList = fService.getUstProvider(new NullProgressMonitor());
 809
 810             // Verify provider info
 811             assertNotNull(providerList);
 812             assertEquals(0, providerList.size());
 813
 814             // Reset version
 815             ((LTTngControlService)fService).setVersion("2.0.0");
 816
 817         } catch (ExecutionException e) {
 818             fail(e.toString());
 819         } finally {
 820             disableVerbose();
 821         }
 822     }
 823
 824
 825
 826     @Test
 827     public void testCreateSession() {
 828         try {
 829             fShell.setScenario(SCEN_CREATE_SESSION1);
 830
 831             ISessionInfo info = fService.createSession(new SessionInfo("mysession2"), new NullProgressMonitor());
 832             assertNotNull(info);
 833             assertEquals("mysession2", info.getName());
 834             assertNotNull(info.getSessionPath());
 835             assertTrue(info.getSessionPath().contains("mysession2"));
 836             assertEquals(TraceSessionState.INACTIVE, info.getSessionState());
 837         } catch (ExecutionException e) {
 838             fail(e.toString());
 839         }
 840     }
 841
 842     @Test
 843     public void testCreateSessionWithPrompt() {
 844         try {
 845             // First line has the shell prompt before the command output
 846             // This can happen in a real application if the command line is not echoed by the shell.
 847             fShell.setScenario(SCEN_CREATE_SESSION_WITH_PROMPT);
 848
 849             // First line has no shell prompt before the output
 850             ISessionInfo info = fService.createSession(new SessionInfo("mysession2"), new NullProgressMonitor());
 851             assertNotNull(info);
 852             assertEquals("mysession2", info.getName());
 853             assertNotNull(info.getSessionPath());
 854             assertTrue(info.getSessionPath().contains("mysession2"));
 855             assertEquals(TraceSessionState.INACTIVE, info.getSessionState());
 856         } catch (ExecutionException e) {
 857             fail(e.toString());
 858         }
 859     }
 860
 861     @Test
 862     public void testCreateSessionVariants() {
 863
 864         fShell.setScenario(SCEN_CREATE_SESSION_VARIANTS);
 865
 866         try {
 867             fService.createSession(new SessionInfo("alreadyExist"), new NullProgressMonitor());
 868             fail("No exeption thrown");
 869         } catch (ExecutionException e) {
 870             // success
 871         }
 872
 873         try {
 874             fService.createSession(new SessionInfo("wrongName"), new NullProgressMonitor());
 875             fail("No exeption thrown");
 876         } catch (ExecutionException e) {
 877             // success
 878         }
 879
 880         try {
 881             ISessionInfo sessionInfo = new SessionInfo("withPath");
 882             sessionInfo.setSessionPath("/home/user/hallo");
 883             fService.createSession(sessionInfo, new NullProgressMonitor());
 884             fail("No exeption thrown");
 885         } catch (ExecutionException e) {
 886             // success
 887         }
 888
 889         try {
 890             ISessionInfo info = fService.createSession(new SessionInfo("session with spaces"), new NullProgressMonitor());
 891             assertNotNull(info);
 892             assertEquals("session with spaces", info.getName());
 893             assertNotNull(info.getSessionPath());
 894             assertTrue(info.getSessionPath().contains("session with spaces"));
 895             assertEquals(TraceSessionState.INACTIVE, info.getSessionState());
 896
 897         } catch (ExecutionException e) {
 898             fail(e.toString());
 899         }
 900
 901         try {
 902             ISessionInfo sessionInfo = new SessionInfo("pathWithSpaces");
 903             sessionInfo.setSessionPath("/home/user/hallo user/here");
 904             ISessionInfo info = fService.createSession(sessionInfo, new NullProgressMonitor());
 905             assertNotNull(info);
 906             assertEquals("pathWithSpaces", info.getName());
 907             assertNotNull(info.getSessionPath());
 908             assertTrue(info.getSessionPath().contains("/home/user/hallo user/here"));
 909             assertEquals(TraceSessionState.INACTIVE, info.getSessionState());
 910
 911         } catch (ExecutionException e) {
 912             fail(e.toString());
 913         }
 914     }
 915
 916     @Test
 917     public void testDestroySession() {
 918         try {
 919             fShell.setScenario(SCEN_DESTROY_SESSION1);
 920             fService.destroySession("mysession2", new NullProgressMonitor());
 921         } catch (ExecutionException e) {
 922             fail(e.toString());
 923         }
 924     }
 925
 926     @Test
 927     public void testDestroySessionVerbose() {
 928         try {
 929             enableVerbose();
 930             fShell.setScenario(SCEN_DESTROY_SESSION_VERBOSE);
 931             fService.destroySession("mysession2", new NullProgressMonitor());
 932         } catch (ExecutionException e) {
 933             fail(e.toString());
 934         } finally {
 935             disableVerbose();
 936         }
 937     }
 938
 939     @Test
 940     public void testCreateChannel() {
 941         try {
 942             ((LTTngControlService)fService).setVersion("2.2.0");
 943             String sessionName = "mysession2";
 944             List<String> list = new ArrayList<>();
 945             String kernelChannel0 = "mychannel0";
 946             String kernelChannel1 = "mychannel1";
 947             list.add(kernelChannel0);
 948             list.add(kernelChannel1);
 949
 950             fShell.setScenario(SCEN_CHANNEL_HANDLING);
 951
 952             // Create/enable/configure 2 kernel channels
 953             ChannelInfo chanInfo = new ChannelInfo("");
 954             chanInfo.setOverwriteMode(true);
 955             chanInfo.setSubBufferSize(16384);
 956             chanInfo.setReadTimer(100);
 957             chanInfo.setSwitchTimer(200);
 958             chanInfo.setNumberOfSubBuffers(2);
 959             chanInfo.setMaxNumberTraceFiles(10);
 960             chanInfo.setMaxSizeTraceFiles(0);
 961             fService.enableChannels(sessionName, list, true, chanInfo, new NullProgressMonitor());
 962
 963             // Create/enable/configure 1 UST channel
 964             list.clear();
 965             list.add("ustChannel");
 966
 967             chanInfo = new ChannelInfo("");
 968             chanInfo.setOverwriteMode(true);
 969             chanInfo.setSubBufferSize(32768);
 970             chanInfo.setReadTimer(200);
 971             chanInfo.setSwitchTimer(100);
 972             chanInfo.setNumberOfSubBuffers(1);
 973             chanInfo.setMaxNumberTraceFiles(20);
 974             chanInfo.setMaxSizeTraceFiles(0);
 975             fService.enableChannels(sessionName, list, false, chanInfo, new NullProgressMonitor());
 976             ((LTTngControlService)fService).setVersion("2.0.0");
 977
 978         } catch (ExecutionException e) {
 979             fail(e.toString());
 980         }
 981     }
 982
 983     @Test
 984     public void testCreateChannelUIDBuffer() {
 985         try {
 986             ((LTTngControlService)fService).setVersion("2.2.0");
 987             String sessionName = "mysession2";
 988             List<String> list = new ArrayList<>();
 989             String USTChannel = "ustChannel";
 990             list.add(USTChannel);
 991             fShell.setScenario(SCEN_CHANNEL_HANDLING);
 992
 993             ChannelInfo chanInfo = new ChannelInfo("");
 994             chanInfo.setOverwriteMode(true);
 995             chanInfo.setSubBufferSize(32768);
 996             chanInfo.setReadTimer(200);
 997             chanInfo.setSwitchTimer(100);
 998             chanInfo.setNumberOfSubBuffers(1);
 999             chanInfo.setMaxNumberTraceFiles(20);
1000             chanInfo.setMaxSizeTraceFiles(0);
1001             chanInfo.setBufferType(BufferType.BUFFER_PER_UID);
1002             fService.enableChannels(sessionName, list, false, chanInfo, new NullProgressMonitor());
1003             ((LTTngControlService)fService).setVersion("2.0.0");
1004
1005         } catch (ExecutionException e) {
1006             fail(e.toString());
1007         }
1008     }
1009
1010     @Test
1011     public void testCreateChannelPIDBuffer() {
1012         try {
1013             ((LTTngControlService)fService).setVersion("2.2.0");
1014             String sessionName = "mysession2";
1015             List<String> list = new ArrayList<>();
1016             String USTChannel = "ustChannel";
1017             list.add(USTChannel);
1018             fShell.setScenario(SCEN_CHANNEL_HANDLING);
1019
1020
1021             ChannelInfo chanInfo = new ChannelInfo("");
1022             chanInfo.setOverwriteMode(true);
1023             chanInfo.setSubBufferSize(-1);
1024             chanInfo.setReadTimer(-1);
1025             chanInfo.setSwitchTimer(-1);
1026             chanInfo.setNumberOfSubBuffers(-1);
1027             chanInfo.setMaxNumberTraceFiles(-1);
1028             chanInfo.setMaxSizeTraceFiles(-1);
1029             chanInfo.setBufferType(BufferType.BUFFER_PER_PID);
1030
1031             fService.enableChannels(sessionName, list, false, chanInfo, new NullProgressMonitor());
1032             ((LTTngControlService)fService).setVersion("2.0.0");
1033
1034         } catch (ExecutionException e) {
1035             fail(e.toString());
1036         }
1037     }
1038
1039     @Test
1040     public void testDisableChannel() {
1041         try {
1042
1043             String sessionName = "mysession2";
1044             List<String> list = new ArrayList<>();
1045             String kernelChannel0 = "mychannel0";
1046             String kernelChannel1 = "mychannel1";
1047             list.add(kernelChannel0);
1048             list.add(kernelChannel1);
1049
1050             fShell.setScenario(SCEN_CHANNEL_HANDLING);
1051             fService.disableChannels(sessionName, list, true, new NullProgressMonitor());
1052
1053             list.clear();
1054             list.add("ustChannel");
1055             fService.disableChannels(sessionName, list, false, new NullProgressMonitor());
1056
1057         } catch (ExecutionException e) {
1058             fail(e.toString());
1059         }
1060     }
1061
1062     @Test
1063     public void testEnableChannel() {
1064         try {
1065
1066             String sessionName = "mysession2";
1067             List<String> list = new ArrayList<>();
1068             String kernelChannel0 = "mychannel0";
1069             String kernelChannel1 = "mychannel1";
1070             list.add(kernelChannel0);
1071             list.add(kernelChannel1);
1072
1073             fShell.setScenario(SCEN_CHANNEL_HANDLING);
1074             fService.enableChannels(sessionName, list, true, null, new NullProgressMonitor());
1075
1076             // Create/enable/configure 1 UST channel
1077             list.clear();
1078             list.add("ustChannel");
1079
1080             fService.enableChannels(sessionName, list, false, null, new NullProgressMonitor());
1081
1082         } catch (ExecutionException e) {
1083             fail(e.toString());
1084         }
1085     }
1086
1087     @Test
1088     public void testEnableEvents() {
1089         try {
1090             // 1) session name, channel = null, 3 event names, kernel
1091             String sessionName = "mysession2";
1092             List<String> list = new ArrayList<>();
1093             String eventName0 = "block_rq_remap";
1094             String eventName1 = "block_bio_remap";
1095             String eventName2 = "softirq_entry";
1096             list.add(eventName0);
1097             list.add(eventName1);
1098             list.add(eventName2);
1099             fShell.setScenario(SCEN_EVENT_HANDLING);
1100             fService.enableEvents(sessionName, null, list, true, null, new NullProgressMonitor());
1101
1102             // 2) session name, channel=mychannel, event name= null, kernel
1103             String channelName = "mychannel";
1104             fService.enableEvents(sessionName, channelName, null, true, null, new NullProgressMonitor());
1105
1106             // 3) session name, channel=mychannel, 1 event name, ust, no filter
1107             String ustEventName = "ust_tests_hello:tptest_sighandler";
1108             list.clear();
1109             list.add(ustEventName);
1110             fService.enableEvents(sessionName, channelName, list, false, null, new NullProgressMonitor());
1111
1112             // 4) session name, channel = mychannel, no event name, ust, with filter
1113             fService.enableEvents(sessionName, channelName, list, false, "intfield==10", new NullProgressMonitor());
1114
1115             // 5) session name, channel = mychannel, no event name, ust, no filter
1116             list.clear();
1117             fService.enableEvents(sessionName, channelName, list, false, null, new NullProgressMonitor());
1118
1119             // TODO add test with filters
1120
1121         } catch (ExecutionException e) {
1122             fail(e.toString());
1123         }
1124     }
1125
1126     @Test
1127     public void testEnableSyscalls() {
1128         try {
1129             // 1) session name, channel = null, 3 event names, kernel
1130             String sessionName = "mysession2";
1131             String channelName = "mychannel";
1132
1133             fShell.setScenario(SCEN_EVENT_HANDLING);
1134
1135             // 1) session name, channel = null
1136             fService.enableSyscalls(sessionName, null, new NullProgressMonitor());
1137
1138             // 2) session name, channel = mychannel
1139             fService.enableSyscalls(sessionName, channelName, new NullProgressMonitor());
1140
1141         } catch (ExecutionException e) {
1142             fail(e.toString());
1143         }
1144     }
1145
1146     @Test
1147     public void testDynamicProbe() {
1148         try {
1149             // 1) session name, channel = null, 3 event names, kernel
1150             String sessionName = "mysession2";
1151             String channelName = "mychannel";
1152             String eventName0 = "myevent0";
1153             String eventName1 = "myevent1";
1154             String functionProbe = "0xc0101340";
1155             String dynProbe = "init_post";
1156
1157             fShell.setScenario(SCEN_EVENT_HANDLING);
1158
1159             // 1) session name, channel = null, event name, function probe, probe
1160             fService.enableProbe(sessionName, null, eventName0, true, functionProbe, new NullProgressMonitor());
1161
1162             // 2) session name, channel = mychannel
1163             fService.enableProbe(sessionName, channelName, eventName1, false, dynProbe, new NullProgressMonitor());
1164
1165         } catch (ExecutionException e) {
1166             fail(e.toString());
1167         }
1168     }
1169
1170     @Test
1171     public void testEnableLogLevel() {
1172         try {
1173             // 1) session name, channel = null, 3 event names, kernel
1174             String sessionName = "mysession2";
1175             String channelName = "mychannel";
1176             String eventName4 = "myevent4";
1177             String eventName5 = "myevent5";
1178
1179             fShell.setScenario(SCEN_EVENT_HANDLING);
1180
1181             // 1) session name, channel = null, event name, loglevel-only, TRACE_DEBUG
1182             fService.enableLogLevel(sessionName, null, eventName4, LogLevelType.LOGLEVEL_ONLY, TraceLogLevel.TRACE_DEBUG, null, new NullProgressMonitor());
1183
1184             // 2) session name, channel = mychannel, null, loglevel, TRACE_DEBUG_FUNCTION
1185             fService.enableLogLevel(sessionName, channelName, eventName5, LogLevelType.LOGLEVEL, TraceLogLevel.TRACE_DEBUG_FUNCTION, null, new NullProgressMonitor());
1186
1187             // TODO add test with filters
1188
1189         } catch (ExecutionException e) {
1190             fail(e.toString());
1191         }
1192     }
1193
1194     @Test
1195     public void testAddContext() {
1196         try {
1197             // 1) session name, channel = null, 3 event names, kernel
1198             String sessionName = "mysession2";
1199             String channelName = "mychannel";
1200             String eventName = "ust_tests_hello:tptest_sighandler";
1201             List<String> contexts = new ArrayList<>();
1202             contexts.add("prio");
1203             contexts.add("pid");
1204
1205             fShell.setScenario(SCEN_CONTEXT_HANDLING);
1206
1207             List<String> availContexts = fService.getContextList(new NullProgressMonitor());
1208             assertNotNull(availContexts);
1209             assertEquals(12, availContexts.size());
1210
1211             // A very "hard-coded" way to verify but it works ...
1212             Set<String> expectedContexts = new HashSet<>();
1213             expectedContexts.add("pid");
1214             expectedContexts.add("procname");
1215             expectedContexts.add("prio");
1216             expectedContexts.add("nice");
1217             expectedContexts.add("vpid");
1218             expectedContexts.add("tid");
1219             expectedContexts.add("pthread_id");
1220             expectedContexts.add("vtid");
1221             expectedContexts.add("ppid");
1222             expectedContexts.add("vppid");
1223             expectedContexts.add("perf:cpu-cycles");
1224             expectedContexts.add("perf:cycles");
1225
1226             assertTrue(expectedContexts.containsAll(availContexts));
1227
1228             // 1) session name, channel = null, event name, loglevel-only, TRACE_DEBUG
1229             fService.addContexts(sessionName, channelName, eventName, false, contexts, new NullProgressMonitor());
1230
1231         } catch (ExecutionException e) {
1232             fail(e.toString());
1233         }
1234     }
1235
1236     @Test
1237     public void testAddContextFailure() {
1238
1239         // 1) session name, channel = null, 3 event names, kernel
1240         String sessionName = "mysession2";
1241         String channelName = "mychannel";
1242         String eventName = "ust_tests_hello:tptest_sighandler";
1243         List<String> contexts = new ArrayList<>();
1244         contexts.add("prio");
1245         contexts.add("pid");
1246         fShell.setScenario(SCEN_CONTEXT_ERROR_HANDLING);
1247         try {
1248             fService.getContextList(new NullProgressMonitor());
1249             fail("No exeption generated");
1250         } catch (ExecutionException e) {
1251             // success
1252         }
1253         try {
1254             // 1) session name, channel = null, event name, loglevel-only, TRACE_DEBUG
1255             fService.addContexts(sessionName, channelName, eventName, false, contexts, new NullProgressMonitor());
1256             fail("No exeption generated");
1257         } catch (ExecutionException e) {
1258             // success
1259         }
1260     }
1261
1262     @Test
1263     public void testCalibrate() {
1264         try {
1265             fShell.setScenario(SCEN_CALIBRATE_HANDLING);
1266             fService.calibrate(true, new NullProgressMonitor());
1267
1268         } catch (ExecutionException e) {
1269             fail(e.toString());
1270         }
1271     }
1272
1273     @Test
1274     public void testCalibrateFailure() {
1275         try {
1276             fShell.setScenario(SCEN_CALIBRATE_HANDLING);
1277             fService.calibrate(false, new NullProgressMonitor());
1278             fail("No exeption generated");
1279         } catch (ExecutionException e) {
1280             // success
1281         }
1282     }
1283
1284     @Test
1285     public void testCreateSession2_1() {
1286
1287         try {
1288             fShell.setScenario(SCEN_CREATE_SESSION_2_1);
1289
1290             ISessionInfo sessionInfo = new SessionInfo("mysession");
1291             sessionInfo.setNetworkUrl("net://172.0.0.1");
1292             sessionInfo.setStreamedTrace(true);
1293             ISessionInfo info = fService.createSession(sessionInfo, new NullProgressMonitor());
1294             assertNotNull(info);
1295             assertEquals("mysession", info.getName());
1296             assertEquals("net://172.0.0.1", info.getSessionPath());
1297             assertTrue(info.isStreamedTrace());
1298             fService.destroySession("mysession", new NullProgressMonitor());
1299
1300             sessionInfo = new SessionInfo("mysession");
1301             sessionInfo.setStreamedTrace(true);
1302             sessionInfo.setNetworkUrl("file:///tmp");
1303             info = fService.createSession(sessionInfo, new NullProgressMonitor());
1304             assertNotNull(info);
1305             assertEquals("mysession", info.getName());
1306             assertEquals("file:///tmp", info.getSessionPath());
1307             assertTrue(!info.isStreamedTrace());
1308             fService.destroySession("mysession", new NullProgressMonitor());
1309
1310             sessionInfo = new SessionInfo("mysession");
1311             sessionInfo.setStreamedTrace(true);
1312             sessionInfo.setNetworkUrl("file:///tmp");
1313             info = fService.createSession(sessionInfo, new NullProgressMonitor());
1314             assertNotNull(info);
1315             assertEquals("mysession", info.getName());
1316             assertEquals("file:///tmp", info.getSessionPath());
1317             assertTrue(!info.isStreamedTrace());
1318             fService.destroySession("mysession", new NullProgressMonitor());
1319
1320             sessionInfo = new SessionInfo("mysession");
1321             sessionInfo.setStreamedTrace(true);
1322             sessionInfo.setControlUrl("tcp://172.0.0.1");
1323             sessionInfo.setDataUrl("tcp://172.0.0.1:5343");
1324             info = fService.createSession(sessionInfo, new NullProgressMonitor());
1325             assertNotNull(info);
1326             assertEquals("mysession", info.getName());
1327             assertEquals("", info.getSessionPath()); // the complete network path is not available at this point
1328             assertTrue(info.isStreamedTrace());
1329             fService.destroySession("mysession", new NullProgressMonitor());
1330
1331             sessionInfo = new SessionInfo("mysession");
1332             sessionInfo.setStreamedTrace(true);
1333             sessionInfo.setNetworkUrl("net://172.0.0.1:1234:2345");
1334             info = fService.createSession(sessionInfo, new NullProgressMonitor());
1335             assertNotNull(info);
1336             assertEquals("mysession", info.getName());
1337             assertEquals("net://172.0.0.1:1234:2345", info.getSessionPath());
1338             assertTrue(info.isStreamedTrace());
1339             fService.destroySession("mysession", new NullProgressMonitor());
1340
1341             // verbose
1342             enableVerbose();
1343             sessionInfo = new SessionInfo("mysession");
1344             sessionInfo.setStreamedTrace(true);
1345             sessionInfo.setNetworkUrl("net://172.0.0.1");
1346             info = fService.createSession(sessionInfo, new NullProgressMonitor());
1347             assertNotNull(info);
1348             assertEquals("mysession", info.getName());
1349             assertEquals("net://172.0.0.1", info.getSessionPath());
1350             assertTrue(info.isStreamedTrace());
1351             disableVerbose();
1352             fService.destroySession("mysession", new NullProgressMonitor());
1353
1354
1355         } catch (ExecutionException e) {
1356             fail(e.toString());
1357         }
1358     }
1359
1360     @Test
1361     public void testCreateSessionVerbose2_1() {
1362         try {
1363             fShell.setScenario(SCEN_CREATE_SESSION_VERBOSE_2_1);
1364
1365             enableVerbose();
1366             ISessionInfo sessionInfo = new SessionInfo("mysession");
1367             sessionInfo.setStreamedTrace(true);
1368             sessionInfo.setNetworkUrl("net://172.0.0.1");
1369             ISessionInfo info = fService.createSession(sessionInfo, new NullProgressMonitor());
1370             assertNotNull(info);
1371             assertEquals("mysession", info.getName());
1372             assertEquals("net://172.0.0.1", info.getSessionPath());
1373             assertTrue(info.isStreamedTrace());
1374             fService.destroySession("mysession", new NullProgressMonitor());
1375         } catch (ExecutionException e) {
1376             fail(e.toString());
1377         } finally {
1378             disableVerbose();
1379         }
1380     }
1381
1382     @Test
1383     public void testCreateSnapshotSession() {
1384         try {
1385             fShell.setScenario(SCEN_CREATE_SNAPSHOT_SESSION);
1386             ISessionInfo params = new SessionInfo("mysession");
1387             params.setSnapshot(true);
1388             ISessionInfo sessionInfo = fService.createSession(params, new NullProgressMonitor());
1389             assertNotNull(sessionInfo);
1390             assertEquals("mysession", sessionInfo.getName());
1391             assertTrue(sessionInfo.isSnapshotSession());
1392             assertEquals("", sessionInfo.getSessionPath());
1393             assertTrue(!sessionInfo.isStreamedTrace());
1394
1395             assertEquals(TraceSessionState.INACTIVE, sessionInfo.getSessionState());
1396
1397             List<String> names = fService.getSessionNames(new NullProgressMonitor());
1398             assertEquals(names.get(0), "mysession");
1399
1400             ISnapshotInfo snapshotInfo = fService.getSnapshotInfo("mysession", new NullProgressMonitor());
1401             assertNotNull(snapshotInfo);
1402             assertEquals("snapshot-1", snapshotInfo.getName());
1403             assertEquals("/home/user/lttng-traces/mysession-20130913-141651", snapshotInfo.getSnapshotPath());
1404             assertEquals(1, snapshotInfo.getId());
1405             assertTrue(!snapshotInfo.isStreamedSnapshot());
1406
1407             // we need to set the snapshotInfo to so that the session path is set correctly
1408             sessionInfo.setSnapshotInfo(snapshotInfo);
1409             assertEquals("/home/user/lttng-traces/mysession-20130913-141651", sessionInfo.getSessionPath());
1410
1411             fService.recordSnapshot("mysession", new NullProgressMonitor());
1412
1413             fService.destroySession("mysession", new NullProgressMonitor());
1414
1415         } catch (ExecutionException e) {
1416             fail(e.toString());
1417         }
1418     }
1419
1420     @Test
1421     public void testCreateSnapshotSession2_5() {
1422         try {
1423             fShell.setScenario(SCEN_CREATE_SNAPSHOT_SESSION_2_5);
1424             ISessionInfo params = new SessionInfo("mysession");
1425             params.setSnapshot(true);
1426             ISessionInfo sessionInfo = fService.createSession(params, new NullProgressMonitor());
1427             assertNotNull(sessionInfo);
1428             assertEquals("mysession", sessionInfo.getName());
1429             assertTrue(sessionInfo.isSnapshotSession());
1430             assertEquals("", sessionInfo.getSessionPath());
1431             assertTrue(!sessionInfo.isStreamedTrace());
1432
1433             assertEquals(TraceSessionState.INACTIVE, sessionInfo.getSessionState());
1434
1435             List<String> names = fService.getSessionNames(new NullProgressMonitor());
1436             assertEquals(names.get(0), "mysession");
1437
1438             ISnapshotInfo snapshotInfo = fService.getSnapshotInfo("mysession", new NullProgressMonitor());
1439             assertNotNull(snapshotInfo);
1440             assertEquals("snapshot-1", snapshotInfo.getName());
1441             assertEquals("/home/user/lttng-traces/mysession-20130913-141651", snapshotInfo.getSnapshotPath());
1442             assertEquals(1, snapshotInfo.getId());
1443             assertTrue(!snapshotInfo.isStreamedSnapshot());
1444
1445             // we need to set the snapshotInfo to so that the session path is set correctly
1446             sessionInfo.setSnapshotInfo(snapshotInfo);
1447             assertEquals("/home/user/lttng-traces/mysession-20130913-141651", sessionInfo.getSessionPath());
1448
1449             fService.recordSnapshot("mysession", new NullProgressMonitor());
1450
1451             fService.destroySession("mysession", new NullProgressMonitor());
1452
1453         } catch (ExecutionException e) {
1454             fail(e.toString());
1455         }
1456     }
1457
1458     public void testCreateStreamedSnapshotSession() {
1459         try {
1460             fShell.setScenario(SCEN_CREATE_STREAMED_SNAPSHOT_SESSION);
1461
1462             ISessionInfo params = new SessionInfo("mysession");
1463             params.setNetworkUrl("net://172.0.0.1");
1464             ISessionInfo sessionInfo = fService.createSession(params, new NullProgressMonitor());
1465             assertNotNull(sessionInfo);
1466             assertEquals("mysession", sessionInfo.getName());
1467             assertTrue(sessionInfo.isSnapshotSession());
1468
1469             assertEquals(TraceSessionState.INACTIVE, sessionInfo.getSessionState());
1470             assertTrue(sessionInfo.isStreamedTrace());
1471
1472             List<String> names = fService.getSessionNames(new NullProgressMonitor());
1473             assertEquals(names.get(0), "mysession");
1474
1475             ISnapshotInfo snapshotInfo = sessionInfo.getSnapshotInfo();
1476             assertNotNull(sessionInfo);
1477             assertEquals("snapshot-2", snapshotInfo.getName());
1478             assertEquals("net4://172.0.0.1:5342/", snapshotInfo.getSnapshotPath());
1479             assertEquals(2, snapshotInfo.getId());
1480             assertTrue(snapshotInfo.isStreamedSnapshot());
1481
1482             // we need to set the snapshotInfo to so that the session path is set correctly
1483             sessionInfo.setSnapshotInfo(snapshotInfo);
1484             assertEquals("net4://172.0.0.1:5342/", sessionInfo.getSessionPath());
1485
1486             fService.recordSnapshot("mysession", new NullProgressMonitor());
1487
1488             fService.destroySession("mysession", new NullProgressMonitor());
1489
1490         } catch (ExecutionException e) {
1491             fail(e.toString());
1492         }
1493     }
1494
1495     @Test
1496     public void testCreateSnapshotSessionErrors() {
1497         try {
1498             fShell.setScenario(SCEN_CREATE_SNAPSHOT_SESSION_ERRORS);
1499
1500             List<String> names = fService.getSessionNames(new NullProgressMonitor());
1501             assertEquals(names.get(0), "mysession");
1502         } catch (ExecutionException e) {
1503             fail(e.toString());
1504         }
1505
1506         try {
1507             fService.getSnapshotInfo("blabla", new NullProgressMonitor());
1508             fail("getSnapshoInfo() didn't fail");
1509         } catch (ExecutionException e) {
1510             // successful
1511         }
1512
1513         try {
1514             fService.recordSnapshot("blabla", new NullProgressMonitor());
1515             fail("getSnapshoInfo() didn't fail");
1516         } catch (ExecutionException e) {
1517             // successful
1518         }
1519
1520         try {
1521             fService.recordSnapshot("mysession", new NullProgressMonitor());
1522             fail("getSnapshoInfo() didn't fail");
1523         } catch (ExecutionException e) {
1524             // successful
1525         }
1526     }
1527
1528     @Test
1529     public void testCreateLiveSession() throws ExecutionException {
1530         fShell.setScenario(SCEN_CREATE_LIVE_SESSION);
1531
1532         ISessionInfo params = new SessionInfo("mysession");
1533         params.setLive(true);
1534         params.setStreamedTrace(true);
1535         params.setNetworkUrl("net://127.0.0.1");
1536         ISessionInfo sessionInfo = fService.createSession(params, new NullProgressMonitor());
1537         assertNotNull(sessionInfo);
1538         assertEquals("mysession", sessionInfo.getName());
1539         assertEquals(TraceSessionState.INACTIVE, sessionInfo.getSessionState());
1540         assertTrue(sessionInfo.isStreamedTrace());
1541         assertTrue(sessionInfo.isLive());
1542         assertEquals("net://127.0.0.1", sessionInfo.getSessionPath());
1543         List<String> names = fService.getSessionNames(new NullProgressMonitor());
1544         assertEquals(names.get(0), "mysession");
1545         fService.destroySession("mysession", new NullProgressMonitor());
1546     }
1547
1548     @Test
1549     public void testCreateLiveSessionErrors() {
1550         try {
1551             fShell.setScenario(SCEN_CREATE_LIVE_SESSION_ERRORS);
1552
1553             ISessionInfo parameters = new SessionInfo("mysession");
1554             parameters.setLive(true);
1555             parameters.setSnapshot(true);
1556             fService.createSession(parameters, new NullProgressMonitor());
1557             fail("createSession() didn't fail");
1558         } catch (ExecutionException e) {
1559             // successful
1560         }
1561
1562         try {
1563             ISessionInfo parameters = new SessionInfo("mysession");
1564             parameters.setNetworkUrl("blah");
1565             parameters.setLive(true);
1566             fService.createSession(parameters, new NullProgressMonitor());
1567             fail("createSession() didn't fail");
1568         } catch (ExecutionException e) {
1569             // successful
1570         }
1571
1572         try {
1573             ISessionInfo parameters = new SessionInfo("mysession");
1574             parameters.setControlUrl("net://127.0.0.1");
1575             parameters.setLive(true);
1576             fService.createSession(parameters, new NullProgressMonitor());
1577             fail("createSession() didn't fail");
1578         } catch (ExecutionException e) {
1579             // successful
1580         }
1581     }
1582
1583     private static void enableVerbose() {
1584         // verbose
1585         ControlCommandLogger.init(ControlPreferences.getInstance().getLogfilePath(), false);
1586         ControlPreferences.getInstance().getPreferenceStore().setDefault(ControlPreferences.TRACE_CONTROL_LOG_COMMANDS_PREF, true);
1587         ControlPreferences.getInstance().getPreferenceStore().setDefault(ControlPreferences.TRACE_CONTROL_VERBOSE_LEVEL_PREF, ControlPreferences.TRACE_CONTROL_VERBOSE_LEVEL_V_V_VERBOSE);
1588     }
1589
1590     private static void disableVerbose() {
1591         ControlPreferences.getInstance().getPreferenceStore().setDefault(ControlPreferences.TRACE_CONTROL_LOG_COMMANDS_PREF, false);
1592     }
1593
1594
1595 }