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

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

 * Copyright (c) 2009, 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

 * Contributors:

 *   Francois Chouinard - Initial API and implementation

 *   Francois Chouinard - Adjusted for new Event Model

import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;

import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;

import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;

import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;

import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;

 

/**

 

    private final String fSource = "Source";

 

    private final String fTypeId = "TestType";

    private final String fLabel1 = "AString";

    private final String fLabel2 = "AnInteger";

    // Helper functions

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

 

        final String DIRECTORY = "testfiles";

        final String TEST_STREAM = "A-Test-10K";

        final String path = DIRECTORY + File.separator + TEST_STREAM;

    // Constructors

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

 

    public void testDefaultConstructor() {

        final ITmfEvent event = new TmfEvent();

        assertNull("getTrace", event.getTrace());

        assertNull("getTimestamp", event.getTimestamp());

        assertNull("getSource", event.getSource());

        assertNull("getType", event.getType());

        assertNull("getReference", event.getReference());

    }

 

    public void testFullConstructor() {

        assertNull("getTrace", fEvent1.getTrace());

        assertEquals("getRank", 0, fEvent1.getRank());

        assertEquals("getReference", fReference2, fEvent2.getReference());

    }

 

    public void testNoRankConstructor() {

        final TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);

        assertNull("getTrace", event.getTrace());

        assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());

        assertEquals("getSource", fSource, event.getSource());

        assertEquals("getType", fType, event.getType());

        assertEquals("getReference", fReference1, event.getReference());

    }

 

    public void testConstructorWithTrace() {

        final ITmfTrace<TmfEvent> trace = openTrace();

        final TmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        trace.dispose();

    }

 

    public void testTmfEventCopy() {

        final TmfEvent event = new TmfEvent(fEvent1);

        assertNull("getTrace", event.getTrace());

        assertEquals("getReference", fReference1, event.getReference());

    }

 

        try {

            new TmfEvent(null);

            fail("null copy");

        return trace;

    }

 

    public void testSetTrace() {

        final ITmfTrace<TmfEvent> trace = setupTrace();

        assertNotNull(trace);

        trace.dispose();

    }

 

    public void testSetRank() {

        final TestEvent event = new TestEvent(fEvent1);

        assertEquals("setRank", 0, event.getRank());

        assertEquals("setRank", 0, event.getRank());

    }

 

    public void testSetTimestamp() {

        final TestEvent event = new TestEvent(fEvent1);

        assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());

        assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());

    }

 

    public void testSetSource() {

        final TestEvent event = new TestEvent(fEvent1);

        assertEquals("setSource", fSource, event.getSource());

        assertEquals("setContent", fSource, event.getSource());

    }

 

    public void testSetType() {

        final TestEvent event = new TestEvent(fEvent1);

        assertEquals("setType", fType, event.getType());

        assertEquals("setType", fType, event.getType());

    }

 

    public void testSetContent() {

        final TestEvent event = new TestEvent(fEvent1);

        assertEquals("setContent", fContent1, event.getContent());

        assertEquals("setContent", fContent1, event.getContent());

    }

 

    public void testSetReference() {

        final TestEvent event = new TestEvent(fEvent1);

        assertEquals("setReference", fReference1, event.getReference());

    // clone

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

 

 

        @Override

        public boolean equals(final Object other) {

        }

    }

 

        final ITmfEvent clone = fEvent1.clone();

 

        assertTrue("clone", fEvent1.clone().equals(fEvent1));

        assertEquals("clone", clone, fEvent1);

    }

 

        final TmfEvent event = new MyEvent();

        final TmfEvent clone = event.clone();

 

    // hashCode

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

 

        TmfEvent event1 = new TmfEvent();

        TmfEvent event2 = new TmfEvent();

 

    // equals

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

 

        assertTrue("equals", fEvent1.equals(fEvent1));

        assertTrue("equals", fEvent2.equals(fEvent2));

 

        assertFalse("equals", fEvent2.equals(fEvent1));

    }

 

        final TmfEvent event1 = new TmfEvent(fEvent1);

        final TmfEvent event2 = new TmfEvent(fEvent2);

 

        assertTrue("equals", fEvent2.equals(event2));

    }

 

        final TmfEvent event1 = new TmfEvent(fEvent1);

        final TmfEvent event2 = new TmfEvent(fEvent1);

        final TmfEvent event3 = new TmfEvent(fEvent1);

        assertTrue("equals", event1.equals(event3));

    }

 

        assertFalse("equals", fEvent1.equals(null));

        assertFalse("equals", fEvent2.equals(null));

    }

 

        assertFalse("equals", fEvent1.equals(fEvent1.getType()));

        assertFalse("equals", fEvent1.equals(null));

    }

 

        final ITmfTrace<TmfEvent> trace1 = openTrace();

        final ITmfTrace<TmfEvent> trace2 = openTrace();

 

        trace2.dispose();

    }

 

        final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        assertTrue("equals", event1.equals(event2));

        assertFalse("equals", event2.equals(event1));

    }

 

        final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        assertTrue("equals", event1.equals(event2));

        assertFalse("equals", event2.equals(event1));

    }

 

        final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        assertTrue("equals", event1.equals(event2));

        assertFalse("equals", event2.equals(event1));

    }

 

        final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType,  fContent1, fReference1);

        assertTrue("equals", event1.equals(event2));

        assertFalse("equals", event2.equals(event1));

    }

 

        final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);

        assertTrue("equals", event1.equals(event2));