org.eclipse.linuxtools.lttng2.control.ui.tests/src/org/eclipse/linuxtools/lttng2/control/ui/tests/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.control.ui.tests.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.control.stubs.service.TestRemoteSystemProxy;
  29 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TargetNodeState;
  30 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceEnablement;
  31 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceEventType;
  32 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceLogLevel;
  33 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceSessionState;
  34 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.ITraceControlComponent;
  35 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.BaseEventComponent;
  36 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.KernelProviderComponent;
  37 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TargetNodeComponent;
  38 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceChannelComponent;
  39 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceDomainComponent;
  40 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceEventComponent;
  41 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceProbeEventComponent;
  42 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceProviderGroup;
  43 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceSessionComponent;
  44 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.TraceSessionGroup;
  45 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.model.impl.UstProviderComponent;
  46 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.service.ILttngControlService;
  47 import org.eclipse.linuxtools.internal.lttng2.control.ui.views.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 public class TraceControlTreeModelTest {
  63
  64     // ------------------------------------------------------------------------
  65     // Constants
  66     // ------------------------------------------------------------------------
  67
  68     private static final String TEST_STREAM = "ListInfoTest.cfg";
  69     private static final String SCEN_LIST_INFO_TEST = "ListInfoTest";
  70     private static final String TARGET_NODE_NAME = "myNode";
  71
  72     // ------------------------------------------------------------------------
  73     // Test data
  74     // ------------------------------------------------------------------------
  75
  76     private TestRemoteSystemProxy fProxy;
  77     private String fTestFile;
  78
  79     // ------------------------------------------------------------------------
  80     // Housekeeping
  81     // ------------------------------------------------------------------------
  82
  83     /**
  84      * Perform pre-test initialization.
  85      *
  86      * @throws Exception
  87      *         if the initialization fails for some reason
  88      */
  89     @Before
  90     public void setUp() throws Exception {
  91         fProxy = new TestRemoteSystemProxy();
  92         URL location = FileLocator.find(FrameworkUtil.getBundle(this.getClass()), new Path(TraceControlTestFacility.DIRECTORY + File.separator + TEST_STREAM), null);
  93         File testfile = new File(FileLocator.toFileURL(location).toURI());
  94         fTestFile = testfile.getAbsolutePath();
  95     }
  96
  97     /**
  98      * Perform post-test clean-up.
  99      */
 100     @After
 101     public void tearDown() {
 102         TraceControlTestFacility.getInstance().waitForJobs();
 103     }
 104
 105     /**
 106      * Run the TraceControlComponent.
 107      *
 108      * @throws Exception
 109      *             This will fail the test
 110      */
 111     @Test
 112     public void testTraceControlComponents() throws Exception {
 113
 114         fProxy.setTestFile(fTestFile);
 115         fProxy.setScenario(SCEN_LIST_INFO_TEST);
 116
 117         ITraceControlComponent root = TraceControlTestFacility.getInstance().getControlView().getTraceControlRoot();
 118
 119         ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();
 120         ISystemProfile profile =  registry.createSystemProfile("myProfile", true);
 121         IHost host = registry.createLocalHost(profile, "myProfile", "user");
 122
 123         TargetNodeComponent node = new TargetNodeComponent(TARGET_NODE_NAME, root, host, fProxy);
 124
 125         root.addChild(node);
 126         node.connect();
 127
 128         TraceControlTestFacility.getInstance().waitForJobs();
 129
 130         // ------------------------------------------------------------------------
 131         // Verify Parameters of TargetNodeComponent
 132         // ------------------------------------------------------------------------
 133         assertEquals("LOCALHOST", node.getHostName()); // assigned in createLocalHost() above
 134         assertEquals("LOCALHOST", node.getToolTip()); // assigned in createLocalHost() above
 135         Image connectedImage = node.getImage();
 136         assertNotNull(connectedImage);
 137         assertEquals(TargetNodeState.CONNECTED, node.getTargetNodeState());
 138         assertNotNull(node.getControlService());
 139         ILttngControlService service = node.getControlService();
 140         assertTrue(service instanceof LTTngControlService);
 141         node.setControlService(service);
 142         assertTrue(node.getControlService() instanceof LTTngControlService);
 143
 144         assertTrue(node.isPassiveCommunicationsListener());
 145
 146         // ------------------------------------------------------------------------
 147         // Verify Children of TargetNodeComponent
 148         // ------------------------------------------------------------------------
 149         ITraceControlComponent[] groups = node.getChildren();
 150         assertNotNull(groups);
 151         assertEquals(2, groups.length);
 152
 153         assertTrue(groups[0] instanceof TraceProviderGroup);
 154         assertTrue(groups[1] instanceof TraceSessionGroup);
 155
 156         assertEquals("Provider", groups[0].getName());
 157         assertEquals("Sessions", groups[1].getName());
 158
 159         // ------------------------------------------------------------------------
 160         // Verify TraceProviderGroup
 161         // ------------------------------------------------------------------------
 162         ITraceControlComponent[] providers = groups[0].getChildren();
 163
 164         assertNotNull(providers);
 165         assertEquals(3, providers.length);
 166
 167         // ------------------------------------------------------------------------
 168         // Verify KernelProviderComponent
 169         // ------------------------------------------------------------------------
 170         KernelProviderComponent kernelProvider = (KernelProviderComponent) providers[0];
 171
 172         // ------------------------------------------------------------------------
 173         // Verify event info (kernel provider)
 174         // ------------------------------------------------------------------------
 175         ITraceControlComponent[] events = kernelProvider.getChildren();
 176         assertNotNull(events);
 177         assertEquals(3, events.length);
 178
 179         BaseEventComponent baseEventInfo = (BaseEventComponent) events[0];
 180         assertNotNull(baseEventInfo);
 181         assertEquals("sched_kthread_stop", baseEventInfo.getName());
 182         assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 183         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 184
 185         baseEventInfo = (BaseEventComponent) events[1];
 186         assertEquals("sched_kthread_stop_ret", baseEventInfo.getName());
 187         assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 188         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 189
 190         baseEventInfo = (BaseEventComponent) events[2];
 191         assertEquals("sched_wakeup_new", baseEventInfo.getName());
 192         assertEquals(TraceLogLevel.TRACE_EMERG, baseEventInfo.getLogLevel());
 193         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 194
 195         // ------------------------------------------------------------------------
 196         // Verify UstProviderComponent
 197         // ------------------------------------------------------------------------
 198         UstProviderComponent ustProvider = (UstProviderComponent) providers[1];
 199         assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello [PID=9379]", ustProvider.getName());
 200         assertEquals(9379, ustProvider.getPid());
 201
 202         // ------------------------------------------------------------------------
 203         // Verify event info (UST provider)
 204         // ------------------------------------------------------------------------
 205         events = ustProvider.getChildren();
 206         assertNotNull(events);
 207         assertEquals(2, events.length);
 208
 209         baseEventInfo = (BaseEventComponent) events[0];
 210         assertNotNull(baseEventInfo);
 211         assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
 212         assertEquals(TraceLogLevel.TRACE_DEBUG_MODULE, baseEventInfo.getLogLevel());
 213         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 214
 215         baseEventInfo = (BaseEventComponent) events[1];
 216         assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
 217         assertEquals(TraceLogLevel.TRACE_INFO, baseEventInfo.getLogLevel());
 218         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 219
 220         // ------------------------------------------------------------------------
 221         // Verify UstProviderComponent
 222         // ------------------------------------------------------------------------
 223         ustProvider = (UstProviderComponent) providers[2];
 224         assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello [PID=4852]", ustProvider.getName());
 225         assertEquals(4852, ustProvider.getPid());
 226
 227         // verify getters and setter
 228         verifyUstProviderGettersSetters(ustProvider);
 229
 230         // ------------------------------------------------------------------------
 231         // Verify event info (UST provider)
 232         // ------------------------------------------------------------------------
 233         events = ustProvider.getChildren();
 234         assertNotNull(events);
 235         assertEquals(2, events.length);
 236
 237         baseEventInfo = (BaseEventComponent) events[0];
 238         assertNotNull(baseEventInfo);
 239         assertEquals("ust_tests_hello:tptest_sighandler", baseEventInfo.getName());
 240         assertEquals(TraceLogLevel.TRACE_WARNING, baseEventInfo.getLogLevel());
 241         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 242
 243         baseEventInfo = (BaseEventComponent) events[1];
 244         assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());
 245         assertEquals(TraceLogLevel.TRACE_DEBUG_FUNCTION, baseEventInfo.getLogLevel());
 246         assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());
 247
 248         // verify getters and setters
 249         verifyBaseEventGettersSetters(baseEventInfo);
 250
 251         // ------------------------------------------------------------------------
 252         // Verify TraceSessionGroup
 253         // ------------------------------------------------------------------------
 254         ITraceControlComponent[] sessions = groups[1].getChildren();
 255         assertNotNull(sessions);
 256         assertEquals(2, sessions.length);
 257         for (int i = 0; i < sessions.length; i++) {
 258             assertTrue(sessions[i] instanceof TraceSessionComponent);
 259         }
 260         assertEquals("mysession1", sessions[0].getName());
 261         assertEquals("mysession", sessions[1].getName());
 262
 263         // ------------------------------------------------------------------------
 264         // Verify TraceSessionComponent
 265         // ------------------------------------------------------------------------
 266         TraceSessionComponent session = (TraceSessionComponent)sessions[1];
 267         assertEquals("mysession", session.getName());
 268         assertEquals("/home/user/lttng-traces/mysession-20120129-084256", session.getSessionPath());
 269         assertEquals(TraceSessionState.ACTIVE, session.getSessionState());
 270
 271         // Verify setters and setters
 272         verifySessionGetterSetters(session);
 273
 274         ITraceControlComponent[] domains = session.getChildren();
 275         assertNotNull(domains);
 276         assertEquals(2, domains.length);
 277
 278         // ------------------------------------------------------------------------
 279         // Verify Kernel domain
 280         // ------------------------------------------------------------------------
 281         assertEquals("Kernel", domains[0].getName());
 282         ITraceControlComponent[] channels =  domains[0].getChildren();
 283         assertNotNull(channels);
 284         assertEquals(2, channels.length);
 285
 286         // Verify setters and setters
 287         verifyDomainGettersSetters((TraceDomainComponent) domains[0]);
 288
 289         // ------------------------------------------------------------------------
 290         // Verify Kernel's channel0
 291         // ------------------------------------------------------------------------
 292         assertTrue(channels[0] instanceof TraceChannelComponent);
 293         TraceChannelComponent channel = (TraceChannelComponent) channels[0];
 294         assertEquals("channel0", channel.getName());
 295         assertEquals(4, channel.getNumberOfSubBuffers());
 296         assertEquals("splice()", channel.getOutputType());
 297         assertEquals(false, channel.isOverwriteMode());
 298         assertEquals(200, channel.getReadTimer());
 299         assertEquals(TraceEnablement.ENABLED, channel.getState());
 300         assertEquals(262144, channel.getSubBufferSize());
 301         assertEquals(0, channel.getSwitchTimer());
 302
 303         // ------------------------------------------------------------------------
 304         // Verify event info (kernel, channel0)
 305         // ------------------------------------------------------------------------
 306         ITraceControlComponent[] channel0Events = channel.getChildren();
 307         assertNotNull(channel0Events);
 308         assertEquals(5, channel0Events.length);
 309         assertTrue(channel0Events[0] instanceof TraceEventComponent);
 310         assertTrue(channel0Events[1] instanceof TraceEventComponent);
 311         assertTrue(channel0Events[2] instanceof TraceProbeEventComponent);
 312         assertTrue(channel0Events[3] instanceof TraceProbeEventComponent);
 313         assertTrue(channel0Events[4] instanceof TraceEventComponent);
 314
 315         TraceEventComponent event = (TraceEventComponent) channel0Events[0];
 316         assertEquals("block_rq_remap", event.getName());
 317         assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
 318         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 319         assertEquals(TraceEnablement.ENABLED, event.getState());
 320
 321         event = (TraceEventComponent) channel0Events[1];
 322         assertEquals("block_bio_remap", event.getName());
 323         assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());
 324         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 325         assertEquals(TraceEnablement.DISABLED, event.getState());
 326
 327         TraceProbeEventComponent probeEvent = (TraceProbeEventComponent) channel0Events[2];
 328         assertEquals("myevent2", probeEvent.getName());
 329         assertEquals(TraceLogLevel.LEVEL_UNKNOWN, probeEvent.getLogLevel());
 330         assertEquals(TraceEventType.PROBE, probeEvent.getEventType());
 331         assertEquals(TraceEnablement.ENABLED, probeEvent.getState());
 332         assertEquals("0xc0101340", probeEvent.getAddress());
 333         assertNull(probeEvent.getOffset());
 334         assertNull(probeEvent.getSymbol());
 335
 336         // verify getters and setter
 337         verifyProbeEventGettersSetters(probeEvent);
 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 static 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         ITraceControlComponent[] children = session.getChildren();
 475         TraceDomainComponent[] domains = session.getDomains();
 476
 477         assertEquals(children.length, domains.length);
 478
 479         for (int i = 0; i < domains.length; i++) {
 480             assertEquals(domains[i].getName(), children[i].getName());
 481         }
 482
 483         // restore original values
 484         session.setName(name);
 485         session.setSessionPath(origPath);
 486         session.setSessionState(origState);
 487     }
 488
 489     private static void verifyDomainGettersSetters(TraceDomainComponent domain) {
 490         // save original values
 491         boolean isKernel = domain.isKernel();
 492
 493         domain.setIsKernel(false);
 494         assertFalse(domain.isKernel());
 495         domain.setIsKernel(true);
 496         assertTrue(domain.isKernel());
 497
 498         ITraceControlComponent[] children = domain.getChildren();
 499         TraceChannelComponent[] channels = domain.getChannels();
 500
 501         assertEquals(children.length, channels.length);
 502
 503         for (int i = 0; i < channels.length; i++) {
 504             assertEquals(channels[i].getName(), children[i].getName());
 505         }
 506
 507         String nodeName = domain.getTargetNode().getName();
 508         assertEquals(TARGET_NODE_NAME, nodeName);
 509
 510         // restore original values
 511         domain.setIsKernel(isKernel);
 512     }
 513
 514     private static void verifyBaseEventGettersSetters(BaseEventComponent event) {
 515         // save original values
 516         String name =  event.getName();
 517         TraceLogLevel level = event.getLogLevel();
 518         TraceEventType type = event.getEventType();
 519
 520         // test cases
 521         event.setName("newName");
 522         assertEquals("newName", event.getName());
 523
 524         event.setLogLevel(TraceLogLevel.TRACE_INFO);
 525         assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
 526         event.setLogLevel("TRACE_ALERT");
 527         assertEquals(TraceLogLevel.TRACE_ALERT, event.getLogLevel());
 528
 529         event.setEventType(TraceEventType.UNKNOWN);
 530         assertEquals(TraceEventType.UNKNOWN, event.getEventType());
 531         event.setEventType("tracepoint");
 532         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 533
 534         // restore original values
 535         event.setName(name);
 536         event.setLogLevel(level);
 537         event.setEventType(type);
 538     }
 539
 540     private static void verifyEventGettersSetters(TraceEventComponent event) {
 541         // save original values
 542         String name =  event.getName();
 543         TraceLogLevel level = event.getLogLevel();
 544         TraceEventType type = event.getEventType();
 545         TraceEnablement state = event.getState();
 546
 547         // test cases
 548         event.setName("newName");
 549         assertEquals("newName", event.getName());
 550
 551         event.setLogLevel(TraceLogLevel.TRACE_INFO);
 552         assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());
 553         event.setLogLevel("TRACE_ALERT");
 554         assertEquals(TraceLogLevel.TRACE_ALERT, event.getLogLevel());
 555
 556         event.setEventType(TraceEventType.UNKNOWN);
 557         assertEquals(TraceEventType.UNKNOWN, event.getEventType());
 558         event.setEventType("tracepoint");
 559         assertEquals(TraceEventType.TRACEPOINT, event.getEventType());
 560
 561         event.setState("disabled");
 562         assertEquals(TraceEnablement.DISABLED, event.getState());
 563
 564         Image disabledImage = event.getImage();
 565         assertNotNull(disabledImage);
 566
 567         event.setState(TraceEnablement.ENABLED);
 568         assertEquals(TraceEnablement.ENABLED, event.getState());
 569
 570         Image enabledImage = event.getImage();
 571         assertNotNull(enabledImage);
 572         assertNotSame(enabledImage, disabledImage);
 573
 574         // restore original values
 575         event.setName(name);
 576         event.setLogLevel(level);
 577         event.setEventType(type);
 578         event.setState(state);
 579     }
 580
 581     private static void verifyProbeEventGettersSetters(TraceProbeEventComponent event) {
 582         // save original values
 583         String address = event.getAddress();
 584         String offset = event.getOffset();
 585         String symbol = event.getSymbol();
 586
 587         // test cases
 588         event.setAddress("0xffff1234");
 589         assertEquals("0xffff1234", event.getAddress());
 590
 591         event.setOffset("0x1234");
 592         assertEquals("0x1234", event.getOffset());
 593
 594         event.setSymbol("init");
 595         assertEquals("init", event.getSymbol());
 596
 597         // restore original values
 598         event.setAddress(address);
 599         event.setOffset(offset);
 600         event.setSymbol(symbol);
 601     }
 602
 603     private static void verifyChannelGettersSetters(TraceChannelComponent channel) {
 604         // save original values
 605         String name = channel.getName();
 606         int nbSubBuffers = channel.getNumberOfSubBuffers();
 607         String type = channel.getOutputType();
 608         boolean mode = channel.isOverwriteMode();
 609         long readTimer = channel.getReadTimer();
 610         TraceEnablement state =  channel.getState();
 611         long subBufferSize = channel.getSubBufferSize();
 612         long switchTimer = channel.getSwitchTimer();
 613
 614         // test cases
 615         channel.setName("newName");
 616         assertEquals("newName", channel.getName());
 617
 618         channel.setNumberOfSubBuffers(2);
 619         assertEquals(2, channel.getNumberOfSubBuffers());
 620
 621         channel.setOutputType("splice()");
 622         assertEquals("splice()", channel.getOutputType());
 623
 624         channel.setOverwriteMode(false);
 625         assertEquals(false, channel.isOverwriteMode());
 626
 627         channel.setReadTimer(250);
 628         assertEquals(250, channel.getReadTimer());
 629
 630         channel.setState("enabled");
 631         assertEquals(TraceEnablement.ENABLED, channel.getState());
 632
 633         Image enabledImage = channel.getImage();
 634         assertNotNull(enabledImage);
 635         channel.setState(TraceEnablement.DISABLED);
 636         assertEquals(TraceEnablement.DISABLED, channel.getState());
 637
 638         Image disabledImage = channel.getImage();
 639         assertNotNull(disabledImage);
 640         assertNotSame(enabledImage, disabledImage);
 641
 642         channel.setSubBufferSize(1024);
 643         assertEquals(1024, channel.getSubBufferSize());
 644
 645         channel.setSwitchTimer(1000);
 646         assertEquals(1000, channel.getSwitchTimer());
 647
 648         // restore original values
 649         channel.setName(name);
 650         channel.setNumberOfSubBuffers(nbSubBuffers);
 651         channel.setOutputType(type);
 652         channel.setOverwriteMode(mode);
 653         channel.setReadTimer(readTimer);
 654         channel.setState(state);
 655         channel.setSubBufferSize(subBufferSize);
 656         channel.setSwitchTimer(switchTimer);
 657     }
 658
 659     private static void verifyUstProviderGettersSetters(UstProviderComponent ustProvider) {
 660         // save original values
 661         String name = ustProvider.getName();
 662         int pid = ustProvider.getPid();
 663
 664         // test cases
 665         ustProvider.setName("newName");
 666         assertEquals("newName", ustProvider.getName());
 667
 668         ustProvider.setPid(9876);
 669         assertEquals(9876, ustProvider.getPid());
 670
 671         // restore original values
 672         ustProvider.setName(name);
 673         ustProvider.setPid(pid);
 674     }
 675
 676 }