org.eclipse.linuxtools.lttng2.ui.tests/src/org/eclipse/linuxtools/lttng2/ui/tests/control/model/component/TraceControlTreeModelTest.java

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