[deliverable/tracecompass.git] / tmf / org.eclipse.tracecompass.tmf.ui.tests / src / org / eclipse / tracecompass / tmf / ui / tests / widgets / timegraph / model / TimeGraphEntryTest.java

/*******************************************************************************
 * Copyright (c) 2016 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:
 *   Patrick Tasse - Initial API and implementation
 *******************************************************************************/

package org.eclipse.tracecompass.tmf.ui.tests.widgets.timegraph.model;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.util.Iterator;

import org.eclipse.swt.SWT;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.NullTimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
import org.junit.Test;

import com.google.common.collect.Iterators;

/**
 * Test the {@link TimeGraphEntry} class
 */
public class TimeGraphEntryTest {

    private final static String NAME = "name";

    /**
     * Test method addEvent.
     */
    @Test
    public void testAddEvent() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        entry.addEvent(event1);
        entry.addEvent(event2);
        assertEquals(0, entry.getStartTime());
        assertEquals(20, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2), entry.getTimeEventsIterator());
    }

    /**
     * Test method addEvent with replaced last event.
     */
    @Test
    public void testAddEventReplaceLast() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3a = new TimeEvent(entry, 20, 5, 3);
        ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
        entry.addEvent(event1);
        entry.addEvent(event2);
        entry.addEvent(event3a);
        // last event is replaced
        entry.addEvent(event3);
        assertEquals(0, entry.getStartTime());
        assertEquals(30, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
    }

    /**
     * Test method addEvent with null events.
     */
    @Test
    public void testAddEventNulls() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new NullTimeEvent(entry, 0, 10);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3 = new NullTimeEvent(entry, 20, 10);
        // null events do not affect start and end time
        entry.addEvent(event1);
        entry.addEvent(event2);
        entry.addEvent(event3);
        assertEquals(10, entry.getStartTime());
        assertEquals(20, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
    }
    /**
     * Test method addZoomedEvent.
     */
    @Test
    public void testaddZoomedEvent() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        assertEquals(0, entry.getStartTime());
        assertEquals(20, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2), entry.getTimeEventsIterator());
    }

    /**
     * Test method addZoomedEvent with duplicates.
     */
    @Test
    public void testaddZoomedEventDuplicate() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        // duplicate events are not added twice
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        entry.addZoomedEvent(event3);
        assertEquals(0, entry.getStartTime());
        assertEquals(30, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
    }

    /**
     * Test method addZoomedEvent with replaced last event.
     */
    @Test
    public void testaddZoomedEventReplaceLast() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3a = new TimeEvent(entry, 20, 5, 3);
        ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        entry.addZoomedEvent(event3a);
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        // last event is replaced
        entry.addZoomedEvent(event3);
        assertEquals(0, entry.getStartTime());
        assertEquals(30, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
    }

    /**
     * Test method addZoomedEvent with null events.
     */
    @Test
    public void testAddZoomedEventNulls() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new NullTimeEvent(entry, 0, 10);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3 = new NullTimeEvent(entry, 20, 10);
        // null events do not affect start and end time
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        entry.addZoomedEvent(event3);
        assertEquals(10, entry.getStartTime());
        assertEquals(20, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
    }

    /**
     * Test method addZoomedEvent with partial list restarted.
     */
    @Test
    public void testaddZoomedEventPartialRestart() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
        entry.addZoomedEvent(event2);
        entry.addZoomedEvent(event3);
        // zoomed list is cleared and restarted
        entry.addZoomedEvent(event1);
        entry.addZoomedEvent(event2);
        entry.addZoomedEvent(event3);
        assertEquals(0, entry.getStartTime());
        assertEquals(30, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
    }

    /**
     * Test method getTimeEventsIterator with event list and zoomed list.
     */
    @Test
    public void testGetTimeEventsIteratorMixed() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
        ITimeEvent event2a = new TimeEvent(entry, 10, 5, 4);
        ITimeEvent event2b = new TimeEvent(entry, 15, 5, 5);
        entry.addEvent(event1);
        entry.addEvent(event2);
        entry.addEvent(event3);
        // zoomed events override normal events they overlap completely
        entry.addZoomedEvent(event2a);
        entry.addZoomedEvent(event2b);
        assertEquals(0, entry.getStartTime());
        assertEquals(30, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1, event2a, event2b, event3), entry.getTimeEventsIterator());
    }

    /**
     * Test method getTimeEventsIterator with event list and zoomed list partially overlapping.
     */
    @Test
    public void testGetTimeEventsIteratorMixedSplit() {
        TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
        ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
        ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
        ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
        ITimeEvent event2a = new TimeEvent(entry, 5, 10, 4);
        ITimeEvent event2b = new TimeEvent(entry, 15, 10, 5);
        ITimeEvent event1s = new TimeEvent(entry, 0, 5, 1);
        ITimeEvent event3s = new TimeEvent(entry, 25, 5, 3);
        entry.addEvent(event1);
        entry.addEvent(event2);
        entry.addEvent(event3);
        // zoomed events split and override normal events they overlap partially
        entry.addZoomedEvent(event2a);
        entry.addZoomedEvent(event2b);
        assertEquals(0, entry.getStartTime());
        assertEquals(30, entry.getEndTime());
        assertIteratorsEqual(Iterators.forArray(event1s, event2a, event2b, event3s), entry.getTimeEventsIterator());
    }

    private static void assertIteratorsEqual(Iterator<ITimeEvent> expected, Iterator<ITimeEvent> actual) {
        int i = 0;
        while (expected.hasNext()) {
            assertTrue("missing event at position " + i, actual.hasNext());
            ITimeEvent e1 = expected.next();
            ITimeEvent e2 = actual.next();
            assertEquals("not equal events at position " + i, e1, e2);
            i++;
        }
        assertFalse("extra event at position " + i, actual.hasNext());
    }
}
Commit	Line	Data
9597a3b5 PT	1	/*******************************************************************************
	2	* Copyright (c) 2016 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	* Patrick Tasse - Initial API and implementation
	11	*******************************************************************************/
	12
	13	package org.eclipse.tracecompass.tmf.ui.tests.widgets.timegraph.model;
	14
	15	import static org.junit.Assert.assertEquals;
	16	import static org.junit.Assert.assertFalse;
	17	import static org.junit.Assert.assertTrue;
	18
	19	import java.util.Iterator;
	20
	21	import org.eclipse.swt.SWT;
	22	import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
	23	import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.NullTimeEvent;
	24	import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeEvent;
	25	import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
	26	import org.junit.Test;
	27
	28	import com.google.common.collect.Iterators;
	29
	30	/**
	31	* Test the {@link TimeGraphEntry} class
	32	*/
	33	public class TimeGraphEntryTest {
	34
	35	private final static String NAME = "name";
	36
	37	/**
	38	* Test method addEvent.
	39	*/
	40	@Test
	41	public void testAddEvent() {
	42	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
	43	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
	44	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
	45	entry.addEvent(event1);
	46	entry.addEvent(event2);
	47	assertEquals(0, entry.getStartTime());
	48	assertEquals(20, entry.getEndTime());
	49	assertIteratorsEqual(Iterators.forArray(event1, event2), entry.getTimeEventsIterator());
	50	}
	51
	52	/**
	53	* Test method addEvent with replaced last event.
	54	*/
	55	@Test
	56	public void testAddEventReplaceLast() {
	57	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
	58	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
	59	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
	60	ITimeEvent event3a = new TimeEvent(entry, 20, 5, 3);
	61	ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
	62	entry.addEvent(event1);
	63	entry.addEvent(event2);
	64	entry.addEvent(event3a);
65	// last event is replaced
66	entry.addEvent(event3);
67	assertEquals(0, entry.getStartTime());
68	assertEquals(30, entry.getEndTime());
69	assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
70	}
71
72	/**
73	* Test method addEvent with null events.
74	*/
75	@Test
76	public void testAddEventNulls() {
77	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
78	ITimeEvent event1 = new NullTimeEvent(entry, 0, 10);
79	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
80	ITimeEvent event3 = new NullTimeEvent(entry, 20, 10);
81	// null events do not affect start and end time
82	entry.addEvent(event1);
83	entry.addEvent(event2);
84	entry.addEvent(event3);
85	assertEquals(10, entry.getStartTime());
86	assertEquals(20, entry.getEndTime());
87	assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
88	}
89	/**
90	* Test method addZoomedEvent.
91	*/
92	@Test
93	public void testaddZoomedEvent() {
94	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
95	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
96	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
97	entry.addZoomedEvent(event1);
98	entry.addZoomedEvent(event2);
99	assertEquals(0, entry.getStartTime());
100	assertEquals(20, entry.getEndTime());
101	assertIteratorsEqual(Iterators.forArray(event1, event2), entry.getTimeEventsIterator());
102	}
103
104	/**
105	* Test method addZoomedEvent with duplicates.
106	*/
107	@Test
108	public void testaddZoomedEventDuplicate() {
109	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
110	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
111	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
112	ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
113	entry.addZoomedEvent(event1);
114	entry.addZoomedEvent(event2);
115	// duplicate events are not added twice
116	entry.addZoomedEvent(event1);
117	entry.addZoomedEvent(event2);
118	entry.addZoomedEvent(event3);
119	assertEquals(0, entry.getStartTime());
120	assertEquals(30, entry.getEndTime());
121	assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
122	}
123
124	/**
125	* Test method addZoomedEvent with replaced last event.
126	*/
127	@Test
128	public void testaddZoomedEventReplaceLast() {
129	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
130	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
131	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
132	ITimeEvent event3a = new TimeEvent(entry, 20, 5, 3);
133	ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
134	entry.addZoomedEvent(event1);
135	entry.addZoomedEvent(event2);
136	entry.addZoomedEvent(event3a);
137	entry.addZoomedEvent(event1);
138	entry.addZoomedEvent(event2);
139	// last event is replaced
140	entry.addZoomedEvent(event3);
141	assertEquals(0, entry.getStartTime());
142	assertEquals(30, entry.getEndTime());
143	assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
144	}
145
146	/**
147	* Test method addZoomedEvent with null events.
148	*/
149	@Test
150	public void testAddZoomedEventNulls() {
151	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
152	ITimeEvent event1 = new NullTimeEvent(entry, 0, 10);
153	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
154	ITimeEvent event3 = new NullTimeEvent(entry, 20, 10);
155	// null events do not affect start and end time
156	entry.addZoomedEvent(event1);
157	entry.addZoomedEvent(event2);
158	entry.addZoomedEvent(event3);
159	assertEquals(10, entry.getStartTime());
160	assertEquals(20, entry.getEndTime());
161	assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
162	}
163
164	/**
165	* Test method addZoomedEvent with partial list restarted.
166	*/
167	@Test
168	public void testaddZoomedEventPartialRestart() {
169	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
170	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
171	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
172	ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
173	entry.addZoomedEvent(event2);
174	entry.addZoomedEvent(event3);
175	// zoomed list is cleared and restarted
176	entry.addZoomedEvent(event1);
177	entry.addZoomedEvent(event2);
178	entry.addZoomedEvent(event3);
179	assertEquals(0, entry.getStartTime());
180	assertEquals(30, entry.getEndTime());
181	assertIteratorsEqual(Iterators.forArray(event1, event2, event3), entry.getTimeEventsIterator());
182	}
183
184	/**
185	* Test method getTimeEventsIterator with event list and zoomed list.
186	*/
187	@Test
188	public void testGetTimeEventsIteratorMixed() {
189	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
190	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
191	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
192	ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
193	ITimeEvent event2a = new TimeEvent(entry, 10, 5, 4);
194	ITimeEvent event2b = new TimeEvent(entry, 15, 5, 5);
195	entry.addEvent(event1);
196	entry.addEvent(event2);
197	entry.addEvent(event3);
198	// zoomed events override normal events they overlap completely
199	entry.addZoomedEvent(event2a);
200	entry.addZoomedEvent(event2b);
201	assertEquals(0, entry.getStartTime());
202	assertEquals(30, entry.getEndTime());
203	assertIteratorsEqual(Iterators.forArray(event1, event2a, event2b, event3), entry.getTimeEventsIterator());
204	}
205
206	/**
207	* Test method getTimeEventsIterator with event list and zoomed list partially overlapping.
208	*/
209	@Test
210	public void testGetTimeEventsIteratorMixedSplit() {
211	TimeGraphEntry entry = new TimeGraphEntry(NAME, SWT.DEFAULT, SWT.DEFAULT);
212	ITimeEvent event1 = new TimeEvent(entry, 0, 10, 1);
213	ITimeEvent event2 = new TimeEvent(entry, 10, 10, 2);
214	ITimeEvent event3 = new TimeEvent(entry, 20, 10, 3);
215	ITimeEvent event2a = new TimeEvent(entry, 5, 10, 4);
216	ITimeEvent event2b = new TimeEvent(entry, 15, 10, 5);
217	ITimeEvent event1s = new TimeEvent(entry, 0, 5, 1);
218	ITimeEvent event3s = new TimeEvent(entry, 25, 5, 3);
219	entry.addEvent(event1);
220	entry.addEvent(event2);
221	entry.addEvent(event3);
222	// zoomed events split and override normal events they overlap partially
223	entry.addZoomedEvent(event2a);
224	entry.addZoomedEvent(event2b);
225	assertEquals(0, entry.getStartTime());
226	assertEquals(30, entry.getEndTime());
227	assertIteratorsEqual(Iterators.forArray(event1s, event2a, event2b, event3s), entry.getTimeEventsIterator());
228	}
229
230	private static void assertIteratorsEqual(Iterator<ITimeEvent> expected, Iterator<ITimeEvent> actual) {
231	int i = 0;
232	while (expected.hasNext()) {
233	assertTrue("missing event at position " + i, actual.hasNext());
234	ITimeEvent e1 = expected.next();
235	ITimeEvent e2 = actual.next();
236	assertEquals("not equal events at position " + i, e1, e2);
237	i++;
238	}
239	assertFalse("extra event at position " + i, actual.hasNext());
240	}
241	}