lttng/org.eclipse.tracecompass.lttng2.control.ui.tests/src/org/eclipse/tracecompass/lttng2/control/ui/tests/model/component/TraceControlTreeModelTest.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  *   Markus Schorn - Bug 448058: Use org.eclipse.remote in favor of RSE
  13  **********************************************************************/
  14
  15 package org.eclipse.tracecompass.lttng2.control.ui.tests.model.component;
  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.assertNotSame;
  21 import static org.junit.Assert.assertNull;
  22 import static org.junit.Assert.assertTrue;
  23
  24 import java.io.File;
  25 import java.net.URL;
  26
  27 import org.eclipse.core.runtime.FileLocator;
  28 import org.eclipse.core.runtime.Path;
  29 import org.eclipse.jdt.annotation.NonNull;
  30 import org.eclipse.remote.core.IRemoteConnection;
  31 import org.eclipse.swt.graphics.Image;
  32 import org.eclipse.tracecompass.internal.lttng2.control.core.model.LogLevelType;
  33 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TargetNodeState;
  34 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceChannelOutputType;
  35 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceEnablement;
  36 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceEventType;
  37 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceLogLevel;
  38 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceSessionState;
  39 import org.eclipse.tracecompass.internal.lttng2.control.stubs.service.TestRemoteSystemProxy;
  40 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.ITraceControlComponent;
  41 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.BaseEventComponent;
  42 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.KernelProviderComponent;
  43 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TargetNodeComponent;
  44 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceChannelComponent;
  45 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceDomainComponent;
  46 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceEventComponent;
  47 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceProbeEventComponent;
  48 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceProviderGroup;
  49 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceSessionComponent;
  50 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.TraceSessionGroup;
  51 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.model.impl.UstProviderComponent;
  52 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.service.ILttngControlService;
  53 import org.eclipse.tracecompass.internal.lttng2.control.ui.views.service.LTTngControlService;
  54 import org.eclipse.tracecompass.tmf.remote.core.proxy.TmfRemoteConnectionFactory;
  55 import org.junit.After;
  56 import org.junit.Before;
  57 import org.junit.Test;
  58 import org.osgi.framework.FrameworkUtil;
  59
  60 /**
  61  * The class <code>TraceControlTreeModelTest</code> contains tests for the tree
  62  * component classes.
  63  */
  64 public class TraceControlTreeModelTest {
  65
  66     // ------------------------------------------------------------------------
  67     // Constants
  68     // ------------------------------------------------------------------------
  69     private TraceControlTestFacility fFacility;
  70
  71     private static final String TEST_STREAM = "ListInfoTest.cfg";
  72     private static final String SCEN_LIST_INFO_TEST = "ListInfoTest";
  73     private static final String TARGET_NODE_NAME = "myNode";
  74
  75     // ------------------------------------------------------------------------
  76     // Test data
  77     // ------------------------------------------------------------------------
  78
  79     private IRemoteConnection fHost = TmfRemoteConnectionFactory.getLocalConnection();
  80     private @NonNull TestRemoteSystemProxy fProxy = new TestRemoteSystemProxy(fHost);
  81     private String fTestFile;
  82
  83     // ------------------------------------------------------------------------
  84     // Housekeeping
  85     // ------------------------------------------------------------------------
  86
  87     /**
  88      * Perform pre-test initialization.
  89      *
  90      * @throws Exception
  91      *         if the initialization fails for some reason
  92      */
  93     @Before
  94     public void setUp() throws Exception {
  95         fFacility = TraceControlTestFacility.getInstance();
  96         fFacility.init();
  97         URL location = FileLocator.find(FrameworkUtil.getBundle(this.getClass()), new Path(TraceControlTestFacility.DIRECTORY + File.separator + TEST_STREAM), null);
  98         File testfile = new File(FileLocator.toFileURL(location).toURI());
  99         fTestFile = testfile.getAbsolutePath();
 100     }
 101
 102     /**
 103      * Perform post-test clean-up.
 104      */
 105     @After
 106     public void tearDown() {
 107         fFacility.dispose();
 108     }
 109
 110     /**
 111      * Run the TraceControlComponent.
 112      */
 113     @Test
 114     public void testTraceControlComponents() {
 115
 116         fProxy.setTestFile(fTestFile);
 117         fProxy.setScenario(SCEN_LIST_INFO_TEST);
 118
 119         ITraceControlComponent root = fFacility.getControlView().getTraceControlRoot();
 120
 121         TargetNodeComponent node = new TargetNodeComponent(TARGET_NODE_NAME, root, fProxy);
 122
 123         root.addChild(node);
 124         node.connect();
 125
 126         fFacility.waitForConnect(node);
 127         fFacility.waitForJobs();
 128
 129         // ------------------------------------------------------------------------
 130         // Verify Parameters of TargetNodeComponent
 131         // ------------------------------------------------------------------------
 132         assertEquals("Local", node.getToolTip()); // assigned in createLocalHost() above
 133         Image connectedImage = node.getImage();
 134         assertNotNull(connectedImage);
 135         assertEquals(TargetNodeState.CONNECTED, node.getTargetNodeState());
 136         assertNotNull(node.getControlService());
 137         ILttngControlService service = node.getControlService();
 138         assertTrue(service instanceof LTTngControlService);
 139         node.setControlService(service);
 140         assertTrue(node.getControlService() instanceof LTTngControlService);
 141
 142
 143         // ------------------------------------------------------------------------
 144         // Verify Children of TargetNodeComponent
 145         // ------------------------------------------------------------------------
 146         ITraceControlComponent[] groups = node.getChildren();
 147         assertNotNull(groups);
 148         assertEquals(2, groups.length);
 149
 150         assertTrue(groups[0] instanceof TraceProviderGroup);
 151         assertTrue(groups[1] instanceof TraceSessionGroup);
 152
 153         assertEquals("Provider", groups[0].getName());
 154         assertEquals("Sessions", groups[1].getName());
 155
 156         // ------------------------------------------------------------------------
 157         // Verify TraceProviderGroup
 158         // ------------------------------------------------------------------------
 159         ITraceControlComponent[] providers = groups[0].getChildren();
 160
 161         assertNotNull(providers);
 162         assertEquals(3, providers.length);
 163
 164         // ------------------------------------------------------------------------
 165         // Verify KernelProviderComponent
 166         // ------------------------------------------------------------------------
 167         KernelProviderComponent kernelProvider = (KernelProviderComponent) providers[0];
 168
 169         // ------------------------------------------------------------------------
 170         // Verify event info (kernel provider)
 171         // ------------------------------------------------------------------------
 172         ITraceControlComponent[] events = kernelProvider.getChildren();
 173         assertNotNull(events);
 174         assertEquals(3, events.length);
 175
 176         BaseEventComponent baseEventInfo = (BaseEventComponent) events[0];
 177         assertNotNull(baseEventInfo);
 178         assertEquals("sched_kthread_stop", baseEventInfo.getName());
 179         assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 180         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 181
 182         baseEventInfo = (BaseEventComponent) events[1];
 183         assertEquals("sched_kthread_stop_ret", baseEventInfo.getName());
 184         assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 185         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 186
 187         baseEventInfo = (BaseEventComponent) events[2];
 188         assertEquals("sched_wakeup_new", baseEventInfo.getName());
 189         assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 190         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 191
 192         // ------------------------------------------------------------------------
 193         // Verify UstProviderComponent
 194         // ------------------------------------------------------------------------
 195         UstProviderComponent ustProvider = (UstProviderComponent) providers[1];
 196         assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello [PID=9379]", ustProvider.getName());
 197         assertEquals(9379, ustProvider.getPid());
 198
 199         // ------------------------------------------------------------------------
 200         // Verify event info (UST provider)
 201         // ------------------------------------------------------------------------
 202         events = ustProvider.getChildren();
 203         assertNotNull(events);
 204         assertEquals(2, events.length);
 205
 206         baseEventInfo = (BaseEventComponent) events[0];
 207         assertNotNull(baseEventInfo);
 208         assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
 209         assertEquals(TraceLogLevel.TRACE_DEBUG_MODULE, baseEventInfo.getLogLevel());
 210         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 211
 212         baseEventInfo = (BaseEventComponent) events[1];
 213         assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
 214         assertEquals(TraceLogLevel.TRACE_INFO, baseEventInfo.getLogLevel());
 215         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 216
 217         // ------------------------------------------------------------------------
 218         // Verify UstProviderComponent
 219         // ------------------------------------------------------------------------
 220         ustProvider = (UstProviderComponent) providers[2];
 221         assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello [PID=4852]", ustProvider.getName());
 222         assertEquals(4852, ustProvider.getPid());
 223
 224         // verify getters and setter
 225         verifyUstProviderGettersSetters(ustProvider);
 226
 227         // ------------------------------------------------------------------------
 228         // Verify event info (UST provider)
 229         // ------------------------------------------------------------------------
 230         events = ustProvider.getChildren();
 231         assertNotNull(events);
 232         assertEquals(2, events.length);
 233
 234         baseEventInfo = (BaseEventComponent) events[0];
 235         assertNotNull(baseEventInfo);
 236         assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
 237         assertEquals(TraceLogLevel.TRACE_WARNING, baseEventInfo.getLogLevel());
 238         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 239
 240         baseEventInfo = (BaseEventComponent) events[1];
 241         assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
 242         assertEquals(TraceLogLevel.TRACE_DEBUG_FUNCTION, baseEventInfo.getLogLevel());
 243         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 244
 245         // verify getters and setters
 246         verifyBaseEventGettersSetters(baseEventInfo);
 247
 248         // ------------------------------------------------------------------------
 249         // Verify TraceSessionGroup
 250         // ------------------------------------------------------------------------
 251         ITraceControlComponent[] sessions = groups[1].getChildren();
 252         assertNotNull(sessions);
 253         assertEquals(2, sessions.length);
 254         for (int i = 0; i < sessions.length; i++) {
 255             assertTrue(sessions[i] instanceof TraceSessionComponent);
 256         }
 257         assertEquals("mysession1", sessions[0].getName());
 258         assertEquals("mysession", sessions[1].getName());
 259
 260         // ------------------------------------------------------------------------
 261         // Verify TraceSessionComponent
 262         // ------------------------------------------------------------------------
 263         TraceSessionComponent session = (TraceSessionComponent)sessions[1];
 264         assertEquals("mysession", session.getName());
 265         assertEquals("/home/user/lttng-traces/mysession-20120129-084256", session.getSessionPath());
 266         assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
 267
 268         // Verify setters and setters
 269         verifySessionGetterSetters(session);
 270
 271         ITraceControlComponent[] domains = session.getChildren();
 272         assertNotNull(domains);
 273         assertEquals(2, domains.length);
 274
 275         // ------------------------------------------------------------------------
 276         // Verify Kernel domain
 277         // ------------------------------------------------------------------------
 278         assertEquals("Kernel", domains[0].getName());
 279         ITraceControlComponent[] channels =  domains[0].getChildren();
 280         assertNotNull(channels);
 281         assertEquals(2, channels.length);
 282
 283         // Verify setters and setters
 284         verifyDomainGettersSetters((TraceDomainComponent) domains[0]);
 285
 286         // ------------------------------------------------------------------------
 287         // Verify Kernel's channel0
 288         // ------------------------------------------------------------------------
 289         assertTrue(channels[0] instanceof TraceChannelComponent);
 290         TraceChannelComponent channel = (TraceChannelComponent) channels[0];
 291         assertEquals("channel0", channel.getName());
 292         assertEquals(4, channel.getNumberOfSubBuffers());
 293         assertEquals("splice()", channel.getOutputType().getInName());
 294         assertEquals(TraceChannelOutputType.SPLICE, channel.getOutputType());
 295         assertEquals(false, channel.isOverwriteMode());
 296         assertEquals(200, channel.getReadTimer());
 297         assertEquals(TraceEnablement.ENABLED, channel.getState());
 298         assertEquals(262144, channel.getSubBufferSize());
 299         assertEquals(0, channel.getSwitchTimer());
 300
 301         // ------------------------------------------------------------------------
 302         // Verify event info (kernel, channel0)
 303         // ------------------------------------------------------------------------
 304         ITraceControlComponent[] channel0Events = channel.getChildren();
 305         assertNotNull(channel0Events);
 306         assertEquals(5, channel0Events.length);
 307         assertTrue(channel0Events[0] instanceof TraceEventComponent);
 308         assertTrue(channel0Events[1] instanceof TraceEventComponent);
 309         assertTrue(channel0Events[2] instanceof TraceProbeEventComponent);
 310         assertTrue(channel0Events[3] instanceof TraceProbeEventComponent);
 311         assertTrue(channel0Events[4] instanceof TraceEventComponent);
 312
 313         TraceEventComponent event = (TraceEventComponent) channel0Events[0];
 314         assertEquals("block_rq_remap", event.getName());
 315         assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
 316         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 317         assertEquals(TraceEnablement.ENABLED, event.getState());
 318
 319         event = (TraceEventComponent) channel0Events[1];
 320         assertEquals("block_bio_remap", event.getName());
 321         assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
 322         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 323         assertEquals(TraceEnablement.DISABLED, event.getState());
 324
 325         TraceProbeEventComponent probeEvent = (TraceProbeEventComponent) channel0Events[2];
 326         assertEquals("myevent2", probeEvent.getName());
 327         assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
 328         assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
 329         assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
 330         assertEquals("0xc0101340", probeEvent.getAddress());
 331         assertNull(probeEvent.getOffset());
 332         assertNull(probeEvent.getSymbol());
 333
 334         // verify getters and setter
 335         verifyProbeEventGettersSetters(probeEvent);
 336
 337         probeEvent = (TraceProbeEventComponent) channel0Events[3];
 338         assertEquals("myevent0", probeEvent.getName());
 339         assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
 340         assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
 341         assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
 342         assertNull(probeEvent.getAddress());
 343         assertEquals("0x0", probeEvent.getOffset());
 344         assertEquals("init_post", probeEvent.getSymbol());
 345
 346         event = (TraceEventComponent) channel0Events[4];
 347         assertEquals("syscalls", event.getName());
 348         assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
 349         assertEquals(TraceEventType.SYSCALL, event.getEventType());
 350         assertEquals(TraceEnablement.ENABLED, event.getState());
 351
 352         // ------------------------------------------------------------------------
 353         // Verify Kernel's channel1
 354         // ------------------------------------------------------------------------
 355         assertEquals("channel1", channels[1].getName());
 356         channel = (TraceChannelComponent) channels[1];
 357         assertEquals(4, channel.getNumberOfSubBuffers());
 358         assertEquals("splice()", channel.getOutputType().getInName());
 359         assertEquals(TraceChannelOutputType.SPLICE, channel.getOutputType());
 360         assertEquals(true, channel.isOverwriteMode());
 361         assertEquals(400, channel.getReadTimer());
 362         assertEquals(TraceEnablement.DISABLED, channel.getState());
 363         assertEquals(524288, channel.getSubBufferSize());
 364         assertEquals(100, channel.getSwitchTimer());
 365
 366         // ------------------------------------------------------------------------
 367         // Verify event info (kernel, channel1)
 368         // ------------------------------------------------------------------------
 369         ITraceControlComponent[] channel1Events = channels[1].getChildren();
 370         assertEquals(0, channel1Events.length);
 371
 372         // ------------------------------------------------------------------------
 373         // Verify domain UST global
 374         // ------------------------------------------------------------------------
 375         assertEquals("UST global", domains[1].getName());
 376
 377         ITraceControlComponent[] ustChannels = domains[1].getChildren();
 378
 379         for (int i = 0; i < ustChannels.length; i++) {
 380             assertTrue(ustChannels[i] instanceof TraceChannelComponent);
 381         }
 382
 383         // ------------------------------------------------------------------------
 384         // Verify UST global's mychannel1
 385         // ------------------------------------------------------------------------
 386         channel = (TraceChannelComponent) ustChannels[0];
 387         assertEquals("mychannel1", channel.getName());
 388         assertEquals(8, channel.getNumberOfSubBuffers());
 389         assertEquals("mmap()", channel.getOutputType().getInName());
 390         assertEquals(TraceChannelOutputType.MMAP, channel.getOutputType());
 391         assertEquals(true, channel.isOverwriteMode());
 392         assertEquals(100, channel.getReadTimer());
 393         assertEquals(TraceEnablement.DISABLED, channel.getState());
 394         assertEquals(8192, channel.getSubBufferSize());
 395         assertEquals(200, channel.getSwitchTimer());
 396
 397         // verify getters and setters
 398         verifyChannelGettersSetters(channel);
 399
 400         // ------------------------------------------------------------------------
 401         // Verify event info (UST global, mychannel1)
 402         // ------------------------------------------------------------------------
 403         ITraceControlComponent[] ustEvents = channel.getChildren();
 404         assertEquals(0, ustEvents.length);
 405
 406         // ------------------------------------------------------------------------
 407         // Verify UST global's channel0
 408         // ------------------------------------------------------------------------
 409         channel = (TraceChannelComponent) ustChannels[1];
 410         assertEquals("channel0", channel.getName());
 411         assertEquals(4, channel.getNumberOfSubBuffers());
 412         assertEquals("mmap()", channel.getOutputType().getInName());
 413         assertEquals(TraceChannelOutputType.MMAP, channel.getOutputType());
 414         assertEquals(false, channel.isOverwriteMode());
 415         assertEquals(200, channel.getReadTimer());
 416         assertEquals(TraceEnablement.ENABLED, channel.getState());
 417         assertEquals(4096, channel.getSubBufferSize());
 418         assertEquals(0, channel.getSwitchTimer());
 419
 420         // ------------------------------------------------------------------------
 421         // Verify event info (UST global, channel0)
 422         // ------------------------------------------------------------------------
 423         ustEvents = channel.getChildren();
 424         assertEquals(4, ustEvents.length);
 425
 426         event = (TraceEventComponent) ustEvents[0];
 427         assertEquals("ust_tests_hello:tptest_sighandler", event.getName());
 428         assertEquals(TraceLogLevel.TRACE_DEBUG_LINE, event.getLogLevel());
 429         assertEquals(LogLevelType.LOGLEVEL_ONLY, event.getLogLevelType());
 430         assertEquals(LogLevelType.LOGLEVEL_ONLY.getShortName(), event.getLogLevelType().getShortName());
 431         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 432         assertEquals(TraceEnablement.DISABLED, event.getState());
 433
 434         event = (TraceEventComponent) ustEvents[1];
 435         assertEquals("ust_tests_hello:tptest_sighandler1", event.getName());
 436         assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
 437         assertEquals(LogLevelType.LOGLEVEL, event.getLogLevelType());
 438         assertEquals(LogLevelType.LOGLEVEL.getShortName(), event.getLogLevelType().getShortName());
 439         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 440         assertEquals(TraceEnablement.DISABLED, event.getState());
 441
 442         event = (TraceEventComponent) ustEvents[2];
 443         assertEquals("ust_tests_hello:tptest_sighandler2", event.getName());
 444         assertEquals(TraceLogLevel.TRACE_DEBUG_SYSTEM, event.getLogLevel());
 445         assertEquals(LogLevelType.LOGLEVEL_NONE, event.getLogLevelType());
 446         assertEquals(LogLevelType.LOGLEVEL_NONE.getShortName(), event.getLogLevelType().getShortName());
 447         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 448         assertEquals(TraceEnablement.DISABLED, event.getState());
 449
 450         event = (TraceEventComponent) ustEvents[3];
 451         assertEquals("*", event.getName());
 452         assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());
 453         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 454         assertEquals(TraceEnablement.ENABLED, event.getState());
 455
 456         // verify getters and setters
 457         verifyEventGettersSetters(event);
 458
 459         // disconnect
 460         node.disconnect();
 461         assertEquals(TargetNodeState.DISCONNECTED, node.getTargetNodeState());
 462         assertNotNull(node.getImage());
 463         assertNotSame(connectedImage, node.getImage());
 464
 465         node.getParent().removeChild(node);
 466     }
 467
 468     private static void verifySessionGetterSetters(TraceSessionComponent session) {
 469         // save original values
 470         String name = session.getName();
 471         String origPath = session.getSessionPath();
 472         TraceSessionState origState = session.getSessionState();
 473
 474         // test cases
 475         session.setName("newName");
 476         assertEquals("newName", session.getName());
 477
 478         session.setSessionPath("/home/user/tmp");
 479         assertEquals("/home/user/tmp", session.getSessionPath());
 480
 481         session.setSessionState(TraceSessionState.INACTIVE);
 482         assertEquals(TraceSessionState.INACTIVE, session.getSessionState());
 483         Image inactiveImage = session.getImage();
 484         assertNotNull(inactiveImage);
 485
 486         session.setSessionState("active");
 487         assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
 488
 489         Image activeImage = session.getImage();
 490         assertNotNull(activeImage);
 491         assertNotSame(activeImage, inactiveImage);
 492
 493         ITraceControlComponent[] children = session.getChildren();
 494         TraceDomainComponent[] domains = session.getDomains();
 495
 496         assertEquals(children.length, domains.length);
 497
 498         for (int i = 0; i < domains.length; i++) {
 499             assertEquals(domains[i].getName(), children[i].getName());
 500         }
 501
 502         // restore original values
 503         session.setName(name);
 504         session.setSessionPath(origPath);
 505         session.setSessionState(origState);
 506     }
 507
 508     private static void verifyDomainGettersSetters(TraceDomainComponent domain) {
 509         // save original values
 510         boolean isKernel = domain.isKernel();
 511
 512         domain.setIsKernel(false);
 513         assertFalse(domain.isKernel());
 514         domain.setIsKernel(true);
 515         assertTrue(domain.isKernel());
 516
 517         ITraceControlComponent[] children = domain.getChildren();
 518         TraceChannelComponent[] channels = domain.getChannels();
 519
 520         assertEquals(children.length, channels.length);
 521
 522         for (int i = 0; i < channels.length; i++) {
 523             assertEquals(channels[i].getName(), children[i].getName());
 524         }
 525
 526         String nodeName = domain.getTargetNode().getName();
 527         assertEquals(TARGET_NODE_NAME, nodeName);
 528
 529         // restore original values
 530         domain.setIsKernel(isKernel);
 531     }
 532
 533     private static void verifyBaseEventGettersSetters(BaseEventComponent event) {
 534         // save original values
 535         String name =  event.getName();
 536         TraceLogLevel level = event.getLogLevel();
 537         TraceEventType type = event.getEventType();
 538
 539         // test cases
 540         event.setName("newName");
 541         assertEquals("newName", event.getName());
 542
 543         event.setLogLevel(TraceLogLevel.TRACE_INFO);
 544         assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
 545         event.setLogLevel("TRACE_ALERT");
 546         assertEquals(TraceLogLevel.TRACE_ALERT, event.getLogLevel());
 547
 548         event.setEventType(TraceEventType.UNKNOWN);
 549         assertEquals(TraceEventType.UNKNOWN, event.getEventType());
 550         event.setEventType("tracepoint");
 551         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 552
 553         // restore original values
 554         event.setName(name);
 555         event.setLogLevel(level);
 556         event.setEventType(type);
 557     }
 558
 559     private static void verifyEventGettersSetters(TraceEventComponent event) {
 560         // save original values
 561         String name =  event.getName();
 562         TraceLogLevel level = event.getLogLevel();
 563         TraceEventType type = event.getEventType();
 564         TraceEnablement state = event.getState();
 565
 566         // test cases
 567         event.setName("newName");
 568         assertEquals("newName", event.getName());
 569
 570         event.setLogLevel(TraceLogLevel.TRACE_INFO);
 571         assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
 572         event.setLogLevel("TRACE_ALERT");
 573         assertEquals(TraceLogLevel.TRACE_ALERT, event.getLogLevel());
 574
 575         event.setEventType(TraceEventType.UNKNOWN);
 576         assertEquals(TraceEventType.UNKNOWN, event.getEventType());
 577         event.setEventType("tracepoint");
 578         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 579
 580         event.setState("disabled");
 581         assertEquals(TraceEnablement.DISABLED, event.getState());
 582
 583         Image disabledImage = event.getImage();
 584         assertNotNull(disabledImage);
 585
 586         event.setState(TraceEnablement.ENABLED);
 587         assertEquals(TraceEnablement.ENABLED, event.getState());
 588
 589         Image enabledImage = event.getImage();
 590         assertNotNull(enabledImage);
 591         assertNotSame(enabledImage, disabledImage);
 592
 593         // restore original values
 594         event.setName(name);
 595         event.setLogLevel(level);
 596         event.setEventType(type);
 597         event.setState(state);
 598     }
 599
 600     private static void verifyProbeEventGettersSetters(TraceProbeEventComponent event) {
 601         // save original values
 602         String address = event.getAddress();
 603         String offset = event.getOffset();
 604         String symbol = event.getSymbol();
 605
 606         // test cases
 607         event.setAddress("0xffff1234");
 608         assertEquals("0xffff1234", event.getAddress());
 609
 610         event.setOffset("0x1234");
 611         assertEquals("0x1234", event.getOffset());
 612
 613         event.setSymbol("init");
 614         assertEquals("init", event.getSymbol());
 615
 616         // restore original values
 617         event.setAddress(address);
 618         event.setOffset(offset);
 619         event.setSymbol(symbol);
 620     }
 621
 622     private static void verifyChannelGettersSetters(TraceChannelComponent channel) {
 623         // save original values
 624         String name = channel.getName();
 625         int nbSubBuffers = channel.getNumberOfSubBuffers();
 626         TraceChannelOutputType type = channel.getOutputType();
 627         boolean mode = channel.isOverwriteMode();
 628         long readTimer = channel.getReadTimer();
 629         TraceEnablement state =  channel.getState();
 630         long subBufferSize = channel.getSubBufferSize();
 631         long switchTimer = channel.getSwitchTimer();
 632
 633         // test cases
 634         channel.setName("newName");
 635         assertEquals("newName", channel.getName());
 636
 637         channel.setNumberOfSubBuffers(2);
 638         assertEquals(2, channel.getNumberOfSubBuffers());
 639
 640         channel.setOutputType("splice()");
 641         assertEquals("splice()", channel.getOutputType().getInName());
 642         assertEquals(TraceChannelOutputType.SPLICE, channel.getOutputType());
 643
 644         channel.setOverwriteMode(false);
 645         assertEquals(false, channel.isOverwriteMode());
 646
 647         channel.setReadTimer(250);
 648         assertEquals(250, channel.getReadTimer());
 649
 650         channel.setState("enabled");
 651         assertEquals(TraceEnablement.ENABLED, channel.getState());
 652
 653         Image enabledImage = channel.getImage();
 654         assertNotNull(enabledImage);
 655         channel.setState(TraceEnablement.DISABLED);
 656         assertEquals(TraceEnablement.DISABLED, channel.getState());
 657
 658         Image disabledImage = channel.getImage();
 659         assertNotNull(disabledImage);
 660         assertNotSame(enabledImage, disabledImage);
 661
 662         channel.setSubBufferSize(1024);
 663         assertEquals(1024, channel.getSubBufferSize());
 664
 665         channel.setSwitchTimer(1000);
 666         assertEquals(1000, channel.getSwitchTimer());
 667
 668         // restore original values
 669         channel.setName(name);
 670         channel.setNumberOfSubBuffers(nbSubBuffers);
 671         channel.setOutputType(type);
 672         channel.setOverwriteMode(mode);
 673         channel.setReadTimer(readTimer);
 674         channel.setState(state);
 675         channel.setSubBufferSize(subBufferSize);
 676         channel.setSwitchTimer(switchTimer);
 677     }
 678
 679     private static void verifyUstProviderGettersSetters(UstProviderComponent ustProvider) {
 680         // save original values
 681         String name = ustProvider.getName();
 682         int pid = ustProvider.getPid();
 683
 684         // test cases
 685         ustProvider.setName("newName");
 686         assertEquals("newName", ustProvider.getName());
 687
 688         ustProvider.setPid(9876);
 689         assertEquals(9876, ustProvider.getPid());
 690
 691         // restore original values
 692         ustProvider.setName(name);
 693         ustProvider.setPid(pid);
 694     }
 695
 696 }