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

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