1 /*******************************************************************************
2 * Copyright (c) 2016 Ericsson
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 *******************************************************************************/
10 package org
.eclipse
.tracecompass
.segmentstore
.core
.tests
;
12 import static org
.eclipse
.tracecompass
.common
.core
.NonNullUtils
.checkNotNull
;
13 import static org
.junit
.Assert
.assertEquals
;
14 import static org
.junit
.Assert
.assertFalse
;
15 import static org
.junit
.Assert
.assertTrue
;
17 import java
.util
.ArrayList
;
18 import java
.util
.Arrays
;
19 import java
.util
.Collection
;
20 import java
.util
.Iterator
;
21 import java
.util
.List
;
23 import org
.eclipse
.jdt
.annotation
.NonNull
;
24 import org
.eclipse
.tracecompass
.segmentstore
.core
.BasicSegment
;
25 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegment
;
26 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegmentStore
;
27 import org
.junit
.After
;
28 import org
.junit
.Before
;
29 import org
.junit
.Test
;
31 import com
.google
.common
.collect
.ImmutableList
;
32 import com
.google
.common
.collect
.Iterables
;
33 import com
.google
.common
.collect
.Lists
;
36 * Unit tests for intersecting elements in an SegmentStore
38 * Originally the TreeMapStoreTest, copied for this internal implementation. The
39 * test was barely changed as it tests the interface and not the internals.
41 * @author Matthew Khouzam
43 public abstract class AbstractTestSegmentStore
{
48 protected ISegmentStore
<@NonNull ISegment
> fSegmentStore
;
51 * Get the segment store to test
53 * @return the segment store
55 protected abstract ISegmentStore
<@NonNull ISegment
> getSegmentStore();
57 private static final @NonNull ISegment SEGMENT_2_6
= new BasicSegment(2, 6);
58 private static final @NonNull ISegment SEGMENT_4_6
= new BasicSegment(4, 6);
59 private static final @NonNull ISegment SEGMENT_4_8
= new BasicSegment(4, 8);
60 private static final @NonNull ISegment SEGMENT_6_8
= new BasicSegment(6, 8);
61 private static final @NonNull ISegment SEGMENT_10_14
= new BasicSegment(10, 14);
63 * A sample segment list
65 protected static final List
<@NonNull ISegment
> SEGMENTS
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_6
, SEGMENT_4_8
, SEGMENT_6_8
, SEGMENT_10_14
);
66 private static final List
<@NonNull ISegment
> REVERSE_SEGMENTS
= Lists
.reverse(SEGMENTS
);
71 public AbstractTestSegmentStore() {
76 * Initialize data (test vector) that will be tested
80 fSegmentStore
= getSegmentStore();
81 for (ISegment segment
: SEGMENTS
) {
82 fSegmentStore
.add(segment
);
87 * Dispose of the segment store
90 public void teardown() {
91 fSegmentStore
.dispose();
95 * Testing method size()
98 public void testSize() {
99 assertEquals(SEGMENTS
.size(), fSegmentStore
.size());
103 * Test the contains() method.
106 public void testContains() {
107 ISegment otherSegment
= new BasicSegment(0, 20);
109 assertTrue(fSegmentStore
.contains(SEGMENT_2_6
));
110 assertTrue(fSegmentStore
.contains(SEGMENT_4_8
));
111 assertFalse(fSegmentStore
.contains(otherSegment
));
115 * Test the toArray() method.
118 public void testToObjectArray() {
119 Object
[] array
= fSegmentStore
.toArray();
121 assertEquals(SEGMENTS
.size(), array
.length
);
122 assertTrue(Arrays
.asList(array
).containsAll(SEGMENTS
));
126 * Test the toArray(T[]) method.
129 public void testToSpecificArray() {
130 ISegment
[] array
= fSegmentStore
.toArray(new ISegment
[0]);
132 assertEquals(SEGMENTS
.size(), array
.length
);
133 assertTrue(Arrays
.asList(array
).containsAll(SEGMENTS
));
137 * Test the toArray(T[]) method with a subtype of ISegment.
140 public void testToSpecifyArraySubtype() {
141 ISegmentStore
<@NonNull ISegment
> tms2
= getSegmentStore();
142 BasicSegment otherSegment
= new BasicSegment(2, 6);
143 tms2
.add(otherSegment
);
144 BasicSegment
[] array
= tms2
.toArray(new BasicSegment
[0]);
146 assertEquals(1, array
.length
);
147 assertTrue(Arrays
.asList(array
).contains(otherSegment
));
153 * Test the iteration order of the complete segment store.
156 public void testIterationOrder() {
158 for (ISegment segment
: fSegmentStore
) {
159 assertEquals(SEGMENTS
.get(i
++), segment
);
164 * Test the iteration order when the elements are not inserted in sorted
168 public void testIterationOrderNonSortedInsertion() {
169 /* Prepare the segment store, we don't use the 'fixture' in this test */
170 ISegmentStore
<@NonNull ISegment
> store
= getSegmentStore();
171 for (ISegment segment
: REVERSE_SEGMENTS
) {
172 store
.add(checkNotNull(segment
));
176 * Test each element one by one, the iteration order should follow the
177 * start times, not the insertion order.
180 for (ISegment segment
: store
) {
181 assertEquals(SEGMENTS
.get(i
++), segment
);
184 /* Manually dispose our own store */
190 * {@link ISegmentStore#getIntersectingElements(long start, long end)}
193 public void testGetIntersectingElementsRange() {
195 Iterable
<ISegment
> intersectingElements
;
198 * Range that does not include any segment
200 intersectingElements
= fSegmentStore
.getIntersectingElements(16, 20);
201 assertEquals(0, Iterables
.size(intersectingElements
));
204 * Range start time : Before first segment start time Range end time :
205 * After last segment end time
207 intersectingElements
= fSegmentStore
.getIntersectingElements(1, 15);
208 assertEquals(5, Iterables
.size(intersectingElements
));
211 * Range start time : On first segment start time Range end time : On
212 * last segment end time
214 intersectingElements
= fSegmentStore
.getIntersectingElements(2, 14);
215 assertEquals(5, Iterables
.size(intersectingElements
));
218 * Range start time : After one segment start time Range end time :
219 * Before one segment end time
221 intersectingElements
= fSegmentStore
.getIntersectingElements(11, 13);
222 assertEquals(1, Iterables
.size(intersectingElements
));
223 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
226 * Range start time : On one segment start time Range end time : On one
229 intersectingElements
= fSegmentStore
.getIntersectingElements(10, 14);
230 assertEquals(1, Iterables
.size(intersectingElements
));
231 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
234 * Range start time : On last segment end time Range end time : After
235 * last segment end time
237 intersectingElements
= fSegmentStore
.getIntersectingElements(14, 18);
238 assertEquals(1, Iterables
.size(intersectingElements
));
239 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
242 * Range start time : Before first segment start time Range end time :
243 * On first segment start time
245 intersectingElements
= fSegmentStore
.getIntersectingElements(1, 2);
246 assertEquals(1, Iterables
.size(intersectingElements
));
247 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
251 * Testing method {@link ISegmentStore#getIntersectingElements(long time)}
254 public void testGetIntersectingElementsTime() {
256 Iterable
<ISegment
> intersectingElements
;
259 * Time between segment start time and end time
261 intersectingElements
= fSegmentStore
.getIntersectingElements(3);
262 assertEquals(1, Iterables
.size(intersectingElements
));
263 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
266 * Time on segment start time
268 intersectingElements
= fSegmentStore
.getIntersectingElements(2);
269 assertEquals(1, Iterables
.size(intersectingElements
));
270 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
273 * Time on segment end time
275 intersectingElements
= fSegmentStore
.getIntersectingElements(14);
276 assertEquals(1, Iterables
.size(intersectingElements
));
277 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
280 * Time overlapping many segments
282 intersectingElements
= fSegmentStore
.getIntersectingElements(6);
283 assertEquals(4, Iterables
.size(intersectingElements
));
286 * Time between segments
288 intersectingElements
= fSegmentStore
.getIntersectingElements(9);
289 assertEquals(0, Iterables
.size(intersectingElements
));
292 * Time before all segment start time
294 intersectingElements
= fSegmentStore
.getIntersectingElements(1);
295 assertEquals(0, Iterables
.size(intersectingElements
));
298 * Time after all segment end time
300 intersectingElements
= fSegmentStore
.getIntersectingElements(15);
301 assertEquals(0, Iterables
.size(intersectingElements
));
305 * Testing method {@link ISegmentStore#dispose()}
308 public void testDispose() {
309 ISegmentStore
<@NonNull ISegment
> store
= getSegmentStore();
310 store
.add(SEGMENT_2_6
);
312 assertEquals(0, store
.size());
316 * Test iterating over a store being built.
321 public void testIterator() {
322 Collection
<@NonNull ISegment
> beforeExpected
= ImmutableList
.of(SEGMENT_2_6
);
323 Collection
<@NonNull ISegment
> afterExpected
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_8
);
324 Collection
<@NonNull ISegment
> lastExpected
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_8
, SEGMENT_6_8
);
325 Collection
<@NonNull ISegment
> fixture
= new ArrayList
<>();
326 ISegmentStore
<@NonNull ISegment
> store
= getSegmentStore();
328 // Add one segment to the segment store and iterate
329 store
.add(SEGMENT_2_6
);
330 for (ISegment item
: store
) {
333 assertEquals(beforeExpected
, fixture
);
335 // Add a second segment to the store and iterate
337 store
.add(SEGMENT_4_8
);
338 for (ISegment item
: store
) {
341 assertEquals(afterExpected
, fixture
);
345 Iterator
<@NonNull ISegment
> iter
= store
.iterator();
347 // Add a third segment to the store and iterate
348 store
.add(SEGMENT_6_8
);
349 Iterator
<@NonNull ISegment
> iter2
= store
.iterator();
352 // Make sure the first iterator take has only 2 elements and the second
354 while (iter
.hasNext()) {
355 fixture
.add(iter
.next());
357 assertEquals(afterExpected
, fixture
);
359 while (iter2
.hasNext()) {
360 fixture
.add(iter2
.next());
362 assertEquals(lastExpected
, fixture
);