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