[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / request / TmfRangeFilterTest.java

/*******************************************************************************
 * 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
 *
 * Contributors:
 *   Francois Chouinard - Initial API and implementation
 *******************************************************************************/

package org.eclipse.linuxtools.tmf.core.tests.request;

import junit.framework.TestCase;

import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.TmfRangeFilter;
import org.junit.Test;

/**
 * <b><u>TmfRangeFilterTest</u></b>
 * <p>
 * Test suite for the TmfRangeFilter class.
 */
@SuppressWarnings({"nls","javadoc"})
public class TmfRangeFilterTest extends TestCase {

    // ------------------------------------------------------------------------
    // Constants
    // ------------------------------------------------------------------------

    private static final TmfRangeFilter ALL_EVENTS = TmfRangeFilter.ALL_EVENTS;

    // ------------------------------------------------------------------------
	// Housekeeping
	// ------------------------------------------------------------------------

    /**
     * @param name the test name
     */
	public TmfRangeFilterTest(String name) {
		super(name);
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();
	}

	@Override
	protected void tearDown() throws Exception {
		super.tearDown();
	}

    // ------------------------------------------------------------------------
	// Constructors
	// ------------------------------------------------------------------------

	@Test
	public void testTmfRangeFilter() {
	    TmfRangeFilter filter = ALL_EVENTS;
        assertEquals("getTimeRange", TmfTimeRange.ETERNITY, filter.getTimeRange());

        TmfTimeRange range = TmfTimeRange.NULL_RANGE;
        filter = new TmfRangeFilter(range);
        assertEquals("getTimeRange", range, filter.getTimeRange());

        range = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        filter = new TmfRangeFilter(range);
        assertEquals("getTimeRange", range, filter.getTimeRange());

        range = new TmfTimeRange(new TmfTimestamp(10), TmfTimestamp.BIG_CRUNCH);
        filter = new TmfRangeFilter(range);
        assertEquals("getTimeRange", range, filter.getTimeRange());
	}

    @Test
    public void testTmfRangeFilterCopy() {
        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfRangeFilter filter1 = new TmfRangeFilter(range);
        TmfRangeFilter filter2 = new TmfRangeFilter(filter1);

        assertEquals("getTimeRange",   filter1.getTimeRange(),   filter2.getTimeRange());
    }

    // ------------------------------------------------------------------------
	// equals
	// ------------------------------------------------------------------------

    @Test
    public void testEqualsReflexivity() {
        TmfTimeRange range1 = TmfTimeRange.ETERNITY;
        TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfRangeFilter filter1 = new TmfRangeFilter(range1);
        TmfRangeFilter filter2 = new TmfRangeFilter(range2);

        assertEquals("equals", filter1, filter1);
        assertEquals("equals", filter2, filter2);

        assertFalse("equals", filter1.equals(filter2));
        assertFalse("equals", filter2.equals(filter1));
    }

    @Test
    public void testEqualsSymmetry() {
        TmfTimeRange range1 = TmfTimeRange.ETERNITY;
        TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfRangeFilter filter1 = new TmfRangeFilter(range1);
        TmfRangeFilter filter2 = new TmfRangeFilter(range1);
        TmfRangeFilter filter3 = new TmfRangeFilter(range2);

        assertEquals("equals", filter1, filter2);
        assertEquals("equals", filter2, filter1);

        assertFalse("equals", filter1.equals(filter3));
        assertFalse("equals", filter3.equals(filter1));
    }

    @Test
    public void testEqualsTransivity() {
        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfRangeFilter filter1 = new TmfRangeFilter(range);
        TmfRangeFilter filter2 = new TmfRangeFilter(range);
        TmfRangeFilter filter3 = new TmfRangeFilter(range);

        assertEquals("equals", filter1, filter2);
        assertEquals("equals", filter2, filter3);
        assertEquals("equals", filter3, filter1);
    }

    @Test
    public void testEqualsNull() {
        TmfTimeRange range1 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), TmfTimestamp.BIG_CRUNCH);
        TmfRangeFilter filter1 = new TmfRangeFilter(range1);
        TmfRangeFilter filter2 = new TmfRangeFilter(range2);

        assertFalse("equals", filter1.equals(null));
        assertFalse("equals", filter2.equals(null));
    }

    // ------------------------------------------------------------------------
    // hashCode
    // ------------------------------------------------------------------------

    @Test
    public void testHashCode() {
        TmfTimeRange range1 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), TmfTimestamp.BIG_CRUNCH);
        TmfRangeFilter filter1 = new TmfRangeFilter(range1);
        TmfRangeFilter filter2 = new TmfRangeFilter(range2);

        assertFalse("hashCode",  filter1.hashCode() == filter2.hashCode());
    }

	// ------------------------------------------------------------------------
	// toString
	// ------------------------------------------------------------------------

    @Test
    public void testToString() {
        TmfTimeRange range1 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
        TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), new TmfTimestamp(1000));
        TmfRangeFilter filter1 = new TmfRangeFilter(range1);
        TmfRangeFilter filter2 = new TmfRangeFilter(range2);

        String expected0 = "TmfRangeFilter [fTimeRange=TmfTimeRange [fStartTime=" + TmfTimestamp.BIG_BANG + ", fEndTime=" + TmfTimestamp.BIG_CRUNCH + "]]";
        String expected1 = "TmfRangeFilter [fTimeRange=TmfTimeRange [fStartTime=" + TmfTimestamp.ZERO     + ", fEndTime=" + TmfTimestamp.BIG_CRUNCH + "]]";
        String expected2 = "TmfRangeFilter [fTimeRange=TmfTimeRange [fStartTime=" + new TmfTimestamp(10) + ", fEndTime=" +  new TmfTimestamp(1000) + "]]";

        assertEquals("toString", expected0, TmfRangeFilter.ALL_EVENTS.toString());
        assertEquals("toString", expected1, filter1.toString());
        assertEquals("toString", expected2, filter2.toString());
    }

    // ------------------------------------------------------------------------
    // matches
    // ------------------------------------------------------------------------

    /**
     * The only test that really matters...
     */
    @Test
    public void testMatches() {

        TmfTimeRange range1 = new TmfTimeRange(new TmfTimestamp(0), new TmfTimestamp(1000));
        TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), new TmfTimestamp(2000));

        TmfRangeFilter filter1 = new TmfRangeFilter(range1);
        TmfRangeFilter filter2 = new TmfRangeFilter(range2);

        ITmfEvent event = new TmfEvent(null, 0, new TmfTimestamp(0), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertTrue ("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(5), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertTrue ("matches", filter1.matches(event));
        assertFalse("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(9), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertTrue ("matches", filter1.matches(event));
        assertFalse("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(10), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertTrue ("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(999), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertTrue ("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(1000), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertTrue ("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(1001), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertFalse("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(1999), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertFalse("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(2000), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertFalse("matches", filter1.matches(event));
        assertTrue ("matches", filter2.matches(event));

        event = new TmfEvent(null, 0, new TmfTimestamp(2001), null, null, null, null);
        assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
        assertFalse("matches", filter1.matches(event));
        assertFalse("matches", filter2.matches(event));
    }

}
Commit	Line	Data
8584dc20 FC	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	* Francois Chouinard - Initial API and implementation
	11	*******************************************************************************/
	12
	13	package org.eclipse.linuxtools.tmf.core.tests.request;
	14
	15	import junit.framework.TestCase;
	16
	17	import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
	18	import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
	19	import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
	20	import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
	21	import org.eclipse.linuxtools.tmf.core.request.TmfRangeFilter;
	22	import org.junit.Test;
	23
	24	/**
	25	* <b><u>TmfRangeFilterTest</u></b>
	26	* <p>
	27	* Test suite for the TmfRangeFilter class.
	28	*/
	29	@SuppressWarnings({"nls","javadoc"})
	30	public class TmfRangeFilterTest extends TestCase {
	31
	32	// ------------------------------------------------------------------------
	33	// Constants
	34	// ------------------------------------------------------------------------
	35
	36	private static final TmfRangeFilter ALL_EVENTS = TmfRangeFilter.ALL_EVENTS;
	37
	38	// ------------------------------------------------------------------------
	39	// Housekeeping
	40	// ------------------------------------------------------------------------
	41
	42	/**
	43	* @param name the test name
	44	*/
	45	public TmfRangeFilterTest(String name) {
	46	super(name);
	47	}
	48
	49	@Override
	50	protected void setUp() throws Exception {
	51	super.setUp();
	52	}
	53
	54	@Override
	55	protected void tearDown() throws Exception {
	56	super.tearDown();
	57	}
	58
	59	// ------------------------------------------------------------------------
	60	// Constructors
	61	// ------------------------------------------------------------------------
	62
	63	@Test
	64	public void testTmfRangeFilter() {
65	TmfRangeFilter filter = ALL_EVENTS;
66	assertEquals("getTimeRange", TmfTimeRange.ETERNITY, filter.getTimeRange());
67
68	TmfTimeRange range = TmfTimeRange.NULL_RANGE;
69	filter = new TmfRangeFilter(range);
70	assertEquals("getTimeRange", range, filter.getTimeRange());
71
72	range = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
73	filter = new TmfRangeFilter(range);
74	assertEquals("getTimeRange", range, filter.getTimeRange());
75
76	range = new TmfTimeRange(new TmfTimestamp(10), TmfTimestamp.BIG_CRUNCH);
77	filter = new TmfRangeFilter(range);
78	assertEquals("getTimeRange", range, filter.getTimeRange());
79	}
80
81	@Test
82	public void testTmfRangeFilterCopy() {
83	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
84	TmfRangeFilter filter1 = new TmfRangeFilter(range);
85	TmfRangeFilter filter2 = new TmfRangeFilter(filter1);
86
87	assertEquals("getTimeRange", filter1.getTimeRange(), filter2.getTimeRange());
88	}
89
90	// ------------------------------------------------------------------------
91	// equals
92	// ------------------------------------------------------------------------
93
94	@Test
95	public void testEqualsReflexivity() {
96	TmfTimeRange range1 = TmfTimeRange.ETERNITY;
97	TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
98	TmfRangeFilter filter1 = new TmfRangeFilter(range1);
99	TmfRangeFilter filter2 = new TmfRangeFilter(range2);
100
101	assertEquals("equals", filter1, filter1);
102	assertEquals("equals", filter2, filter2);
103
104	assertFalse("equals", filter1.equals(filter2));
105	assertFalse("equals", filter2.equals(filter1));
106	}
107
108	@Test
109	public void testEqualsSymmetry() {
110	TmfTimeRange range1 = TmfTimeRange.ETERNITY;
111	TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
112	TmfRangeFilter filter1 = new TmfRangeFilter(range1);
113	TmfRangeFilter filter2 = new TmfRangeFilter(range1);
114	TmfRangeFilter filter3 = new TmfRangeFilter(range2);
115
116	assertEquals("equals", filter1, filter2);
117	assertEquals("equals", filter2, filter1);
118
119	assertFalse("equals", filter1.equals(filter3));
120	assertFalse("equals", filter3.equals(filter1));
121	}
122
123	@Test
124	public void testEqualsTransivity() {
125	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
126	TmfRangeFilter filter1 = new TmfRangeFilter(range);
127	TmfRangeFilter filter2 = new TmfRangeFilter(range);
128	TmfRangeFilter filter3 = new TmfRangeFilter(range);
129
130	assertEquals("equals", filter1, filter2);
131	assertEquals("equals", filter2, filter3);
132	assertEquals("equals", filter3, filter1);
133	}
134
135	@Test
136	public void testEqualsNull() {
137	TmfTimeRange range1 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
138	TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), TmfTimestamp.BIG_CRUNCH);
139	TmfRangeFilter filter1 = new TmfRangeFilter(range1);
140	TmfRangeFilter filter2 = new TmfRangeFilter(range2);
141
142	assertFalse("equals", filter1.equals(null));
143	assertFalse("equals", filter2.equals(null));
144	}
145
146	// ------------------------------------------------------------------------
147	// hashCode
148	// ------------------------------------------------------------------------
149
150	@Test
151	public void testHashCode() {
152	TmfTimeRange range1 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
153	TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), TmfTimestamp.BIG_CRUNCH);
154	TmfRangeFilter filter1 = new TmfRangeFilter(range1);
155	TmfRangeFilter filter2 = new TmfRangeFilter(range2);
156
8584dc20 FC	157	assertFalse("hashCode", filter1.hashCode() == filter2.hashCode());
	158	}
	159
	160	// ------------------------------------------------------------------------
	161	// toString
	162	// ------------------------------------------------------------------------
	163
	164	@Test
	165	public void testToString() {
	166	TmfTimeRange range1 = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_CRUNCH);
	167	TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), new TmfTimestamp(1000));
	168	TmfRangeFilter filter1 = new TmfRangeFilter(range1);
	169	TmfRangeFilter filter2 = new TmfRangeFilter(range2);
	170
	171	String expected0 = "TmfRangeFilter [fTimeRange=TmfTimeRange [fStartTime=" + TmfTimestamp.BIG_BANG + ", fEndTime=" + TmfTimestamp.BIG_CRUNCH + "]]";
	172	String expected1 = "TmfRangeFilter [fTimeRange=TmfTimeRange [fStartTime=" + TmfTimestamp.ZERO + ", fEndTime=" + TmfTimestamp.BIG_CRUNCH + "]]";
	173	String expected2 = "TmfRangeFilter [fTimeRange=TmfTimeRange [fStartTime=" + new TmfTimestamp(10) + ", fEndTime=" + new TmfTimestamp(1000) + "]]";
	174
	175	assertEquals("toString", expected0, TmfRangeFilter.ALL_EVENTS.toString());
	176	assertEquals("toString", expected1, filter1.toString());
	177	assertEquals("toString", expected2, filter2.toString());
	178	}
	179
	180	// ------------------------------------------------------------------------
	181	// matches
	182	// ------------------------------------------------------------------------
	183
	184	/**
	185	* The only test that really matters...
	186	*/
	187	@Test
	188	public void testMatches() {
	189
	190	TmfTimeRange range1 = new TmfTimeRange(new TmfTimestamp(0), new TmfTimestamp(1000));
	191	TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(10), new TmfTimestamp(2000));
	192
	193	TmfRangeFilter filter1 = new TmfRangeFilter(range1);
	194	TmfRangeFilter filter2 = new TmfRangeFilter(range2);
	195
	196	ITmfEvent event = new TmfEvent(null, 0, new TmfTimestamp(0), null, null, null, null);
	197	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
	198	assertTrue ("matches", filter1.matches(event));
	199	assertTrue ("matches", filter2.matches(event));
	200
	201	event = new TmfEvent(null, 0, new TmfTimestamp(5), null, null, null, null);
	202	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
	203	assertTrue ("matches", filter1.matches(event));
	204	assertFalse("matches", filter2.matches(event));
	205
	206	event = new TmfEvent(null, 0, new TmfTimestamp(9), null, null, null, null);
	207	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
	208	assertTrue ("matches", filter1.matches(event));
	209	assertFalse("matches", filter2.matches(event));
	210
	211	event = new TmfEvent(null, 0, new TmfTimestamp(10), null, null, null, null);
	212	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
	213	assertTrue ("matches", filter1.matches(event));
	214	assertTrue ("matches", filter2.matches(event));
	215
	216	event = new TmfEvent(null, 0, new TmfTimestamp(999), null, null, null, null);
	217	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
	218	assertTrue ("matches", filter1.matches(event));
	219	assertTrue ("matches", filter2.matches(event));
	220
221	event = new TmfEvent(null, 0, new TmfTimestamp(1000), null, null, null, null);
222	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
223	assertTrue ("matches", filter1.matches(event));
224	assertTrue ("matches", filter2.matches(event));
225
226	event = new TmfEvent(null, 0, new TmfTimestamp(1001), null, null, null, null);
227	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
228	assertFalse("matches", filter1.matches(event));
229	assertTrue ("matches", filter2.matches(event));
230
231	event = new TmfEvent(null, 0, new TmfTimestamp(1999), null, null, null, null);
232	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
233	assertFalse("matches", filter1.matches(event));
234	assertTrue ("matches", filter2.matches(event));
235
236	event = new TmfEvent(null, 0, new TmfTimestamp(2000), null, null, null, null);
237	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
238	assertFalse("matches", filter1.matches(event));
239	assertTrue ("matches", filter2.matches(event));
240
241	event = new TmfEvent(null, 0, new TmfTimestamp(2001), null, null, null, null);
242	assertTrue ("matches", TmfRangeFilter.ALL_EVENTS.matches(event));
243	assertFalse("matches", filter1.matches(event));
244	assertFalse("matches", filter2.matches(event));
245	}
246
247	}