~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

/**********************************************************************

 * Copyright (c) 2012 Ericsson

 * All rights reserved. This program and the accompanying materials are

 * made available under the terms of the Eclipse Public License v1.0 which

 * accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *   Bernd Hufmann - Initial API and implementation

 **********************************************************************/

package org.eclipse.linuxtools.lttng2.ui.tests.control.model.component;

 */

@SuppressWarnings("nls")

public class TraceControlTreeModelTest extends TestCase {

    // ------------------------------------------------------------------------

    // Constants

    // ------------------------------------------------------------------------

    private static final String TEST_STREAM = "ListInfoTest.cfg";

    private static final String SCEN_LIST_INFO_TEST = "ListInfoTest";

    private static final String TARGET_NODE_NAME = "myNode";

    // ------------------------------------------------------------------------

    // Test data

    // ------------------------------------------------------------------------

    private TestRemoteSystemProxy fProxy;

    // ------------------------------------------------------------------------

    // Static methods

    // ------------------------------------------------------------------------

 

    /**

     * Returns test setup used when executing test case stand-alone.

     */

    public static Test suite() {

        return new ModelImplTestSetup(new TestSuite(TraceControlTreeModelTest.class));

    public void tearDown()  throws Exception {

        TraceControlTestFacility.getInstance().waitForJobs();

    }

    /**

     * Run the TraceControlComponent.

     */

        fProxy.setTestFile(fTestFile);

        fProxy.setScenario(SCEN_LIST_INFO_TEST);

        ITraceControlComponent root = TraceControlTestFacility.getInstance().getControlView().getTraceControlRoot();

 

        ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();

        ITraceControlComponent[] groups = node.getChildren();

        assertNotNull(groups);

        assertEquals(2, groups.length);

        assertTrue(groups[0] instanceof TraceProviderGroup);

        assertTrue(groups[1] instanceof TraceSessionGroup);

        assertEquals("Provider", groups[0].getName());

        assertEquals("Sessions", groups[1].getName());

 

        assertEquals(3, providers.length);

 

        // ------------------------------------------------------------------------

        // ------------------------------------------------------------------------

        KernelProviderComponent kernelProvider = (KernelProviderComponent) providers[0];

 

        ustProvider = (UstProviderComponent) providers[2];

        assertEquals("/home/user/git/lttng-ust/tests/hello.cxx/.libs/lt-hello [PID=4852]", ustProvider.getName());

        assertEquals(4852, ustProvider.getPid());

        // verify getters and setter

        verifyUstProviderGettersSetters(ustProvider);

 

        assertEquals("ust_tests_hello:tptest", baseEventInfo.getName());

        assertEquals(TraceLogLevel.TRACE_DEBUG_FUNCTION, baseEventInfo.getLogLevel());

        assertEquals(TraceEventType.TRACEPOINT, baseEventInfo.getEventType());

        // verify getters and setters

        verifyBaseEventGettersSetters(baseEventInfo);

        // ------------------------------------------------------------------------

        // Verify TraceSessionGroup

        // ------------------------------------------------------------------------

 

        // Verify setters and setters

        verifySessionGetterSetters(session);

        ITraceControlComponent[] domains = session.getChildren();

        assertNotNull(domains);

        assertEquals(2, domains.length);

        // ------------------------------------------------------------------------

        // Verify Kernel domain

        // ------------------------------------------------------------------------

 

        // Verify setters and setters

        verifyDomainGettersSetters((TraceDomainComponent) domains[0]);

        // ------------------------------------------------------------------------

        // Verify Kernel's channel0

        // ------------------------------------------------------------------------

        assertTrue(channels[0] instanceof TraceChannelComponent);

        assertEquals("channel0", channel.getName());

        assertEquals(4, channel.getNumberOfSubBuffers());

        assertEquals("splice()", channel.getOutputType());

        assertTrue(channel0Events[2] instanceof TraceProbeEventComponent);

        assertTrue(channel0Events[3] instanceof TraceProbeEventComponent);

        assertTrue(channel0Events[4] instanceof TraceEventComponent);

        TraceEventComponent event = (TraceEventComponent) channel0Events[0];

        assertEquals("block_rq_remap", event.getName());

        assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

        assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

        assertEquals(TraceEnablement.ENABLED, event.getState());

        event = (TraceEventComponent) channel0Events[1];

        assertEquals("block_bio_remap", event.getName());

        assertEquals(TraceLogLevel.TRACE_EMERG, event.getLogLevel());

        assertNull(probeEvent.getAddress());

        assertEquals("0x0", probeEvent.getOffset());

        assertEquals("init_post", probeEvent.getSymbol());

        event = (TraceEventComponent) channel0Events[4];

        assertEquals("syscalls", event.getName());

        assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());

        assertEquals(TraceEventType.SYSCALL, event.getEventType());

        assertEquals(TraceEnablement.ENABLED, event.getState());

        // ------------------------------------------------------------------------

        // Verify Kernel's channel1

        // ------------------------------------------------------------------------

        assertEquals("channel1", channels[1].getName());

        assertEquals(4, channel.getNumberOfSubBuffers());

        assertEquals("splice()", channel.getOutputType());

        assertEquals(true, channel.isOverwriteMode());

        // Verify domain UST global

        // ------------------------------------------------------------------------

        assertEquals("UST global", domains[1].getName());

        ITraceControlComponent[] ustChannels = domains[1].getChildren();

        for (int i = 0; i < ustChannels.length; i++) {

            assertTrue(ustChannels[i] instanceof TraceChannelComponent);

        }

        // ------------------------------------------------------------------------

        // Verify UST global's mychannel1

        // ------------------------------------------------------------------------

        assertEquals("mychannel1", channel.getName());

        assertEquals(8, channel.getNumberOfSubBuffers());

        assertEquals("mmap()", channel.getOutputType());

        assertEquals(TraceEnablement.DISABLED, channel.getState());

        assertEquals(8192, channel.getSubBufferSize());

        assertEquals(200, channel.getSwitchTimer());

        verifyChannelGettersSetters(channel);

 

        // ------------------------------------------------------------------------

        // ------------------------------------------------------------------------

        ustEvents = channel.getChildren();

        assertEquals(2, ustEvents.length);

        event = (TraceEventComponent) ustEvents[0];

        assertEquals("ust_tests_hello:tptest_sighandler", event.getName());

        assertEquals(TraceLogLevel.TRACE_DEBUG_LINE, event.getLogLevel());

        assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

        assertEquals(TraceEnablement.DISABLED, event.getState());

        event = (TraceEventComponent) ustEvents[1];

        assertEquals("*", ustEvents[1].getName());

        assertEquals(TraceLogLevel.LEVEL_UNKNOWN, event.getLogLevel());

        assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

        assertEquals(TraceEnablement.ENABLED, event.getState());

        // verify getters and setters

        verifyEventGettersSetters(event);

        // disconnect

        node.disconnect();

        assertEquals(TargetNodeState.DISCONNECTED, node.getTargetNodeState());

        assertNotNull(node.getImage());

        assertNotSame(connectedImage, node.getImage());

        node.getParent().removeChild(node);

    }

        // save original values

        String name = session.getName();

        String origPath = session.getSessionPath();

        // test cases

        session.setName("newName");

        assertEquals("newName", session.getName());

        session.setSessionPath("/home/user/tmp");

        assertEquals("/home/user/tmp", session.getSessionPath());

 

        assertEquals(TraceSessionState.INACTIVE, session.getSessionState());

        Image inactiveImage = session.getImage();

        assertNotNull(inactiveImage);

        session.setSessionState("active");

        assertEquals(TraceSessionState.ACTIVE, session.getSessionState());

 

        for (int i = 0; i < domains.length; i++) {

            assertEquals(domains[i].getName(), children[i].getName());

        }

        session.setName(name);

        session.setSessionPath(origPath);

        session.setSessionState(origState);

    }

        // save original values

        boolean isKernel = domain.isKernel();

 

        domain.setIsKernel(isKernel);

    }

 

        // save original values

        String name =  event.getName();

        TraceLogLevel level = event.getLogLevel();

        TraceEventType type = event.getEventType();

        // test cases

        event.setName("newName");

        assertEquals("newName", event.getName());

        event.setLogLevel(TraceLogLevel.TRACE_INFO);

        assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());

        event.setLogLevel("TRACE_ALERT");

        assertEquals(TraceEventType.UNKNOWN, event.getEventType());

        event.setEventType("tracepoint");

        assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

        // restore original values

        event.setName(name);

        event.setLogLevel(level);

        event.setEventType(type);

    }

        // save original values

        String name =  event.getName();

        TraceLogLevel level = event.getLogLevel();

        TraceEventType type = event.getEventType();

        TraceEnablement state = event.getState();

        // test cases

        event.setName("newName");

        assertEquals("newName", event.getName());

        event.setLogLevel(TraceLogLevel.TRACE_INFO);

        assertEquals(TraceLogLevel.TRACE_INFO, event.getLogLevel());

        event.setLogLevel("TRACE_ALERT");

        assertEquals(TraceEventType.UNKNOWN, event.getEventType());

        event.setEventType("tracepoint");

        assertEquals(TraceEventType.TRACEPOINT, event.getEventType());

        event.setState("disabled");

        assertEquals(TraceEnablement.DISABLED, event.getState());

        Image disabledImage = event.getImage();