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