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

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