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
.Comparator
;
21 import java
.util
.Iterator
;
22 import java
.util
.LinkedList
;
23 import java
.util
.List
;
25 import org
.eclipse
.jdt
.annotation
.NonNull
;
26 import org
.eclipse
.tracecompass
.common
.core
.NonNullUtils
;
27 import org
.eclipse
.tracecompass
.segmentstore
.core
.BasicSegment
;
28 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegment
;
29 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegmentStore
;
30 import org
.eclipse
.tracecompass
.segmentstore
.core
.SegmentComparators
;
31 import org
.junit
.After
;
32 import org
.junit
.Before
;
33 import org
.junit
.Test
;
35 import com
.google
.common
.collect
.ImmutableList
;
36 import com
.google
.common
.collect
.Iterables
;
37 import com
.google
.common
.collect
.Lists
;
40 * Unit tests for intersecting elements in an SegmentStore
42 * Originally the TreeMapStoreTest, copied for this internal implementation. The
43 * test was barely changed as it tests the interface and not the internals.
45 * @author Matthew Khouzam
47 public abstract class AbstractTestSegmentStore
{
52 protected ISegmentStore
<@NonNull ISegment
> fSegmentStore
;
55 * Get the segment store to test
57 * @return the segment store
59 protected abstract ISegmentStore
<@NonNull ISegment
> getSegmentStore();
61 private static final @NonNull ISegment SEGMENT_2_6
= new BasicSegment(2, 6);
62 private static final @NonNull ISegment SEGMENT_4_6
= new BasicSegment(4, 6);
63 private static final @NonNull ISegment SEGMENT_4_8
= new BasicSegment(4, 8);
64 private static final @NonNull ISegment SEGMENT_6_8
= new BasicSegment(6, 8);
65 private static final @NonNull ISegment SEGMENT_10_14
= new BasicSegment(10, 14);
67 * A sample segment list
69 protected static final List
<@NonNull ISegment
> SEGMENTS
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_6
, SEGMENT_4_8
, SEGMENT_6_8
, SEGMENT_10_14
);
70 private static final List
<@NonNull ISegment
> REVERSE_SEGMENTS
= Lists
.reverse(SEGMENTS
);
75 public AbstractTestSegmentStore() {
80 * Initialize data (test vector) that will be tested
84 fSegmentStore
= getSegmentStore();
85 for (ISegment segment
: SEGMENTS
) {
86 fSegmentStore
.add(segment
);
91 * Dispose of the segment store
94 public void teardown() {
95 fSegmentStore
.dispose();
99 * Testing method size()
102 public void testSize() {
103 assertEquals(SEGMENTS
.size(), fSegmentStore
.size());
107 * Test the contains() method.
110 public void testContains() {
111 ISegment otherSegment
= new BasicSegment(0, 20);
113 assertTrue(fSegmentStore
.contains(SEGMENT_2_6
));
114 assertTrue(fSegmentStore
.contains(SEGMENT_4_8
));
115 assertFalse(fSegmentStore
.contains(otherSegment
));
119 * Test the toArray() method.
122 public void testToObjectArray() {
123 Object
[] array
= fSegmentStore
.toArray();
125 assertEquals(SEGMENTS
.size(), array
.length
);
126 assertTrue(Arrays
.asList(array
).containsAll(SEGMENTS
));
130 * Test the toArray(T[]) method.
133 public void testToSpecificArray() {
134 ISegment
[] array
= fSegmentStore
.toArray(new ISegment
[0]);
136 assertEquals(SEGMENTS
.size(), array
.length
);
137 assertTrue(Arrays
.asList(array
).containsAll(SEGMENTS
));
141 * Test the toArray(T[]) method with a subtype of ISegment.
144 public void testToSpecifyArraySubtype() {
145 ISegmentStore
<@NonNull ISegment
> tms2
= getSegmentStore();
146 BasicSegment otherSegment
= new BasicSegment(2, 6);
147 tms2
.add(otherSegment
);
148 BasicSegment
[] array
= tms2
.toArray(new BasicSegment
[0]);
150 assertEquals(1, array
.length
);
151 assertTrue(Arrays
.asList(array
).contains(otherSegment
));
157 * Test the iteration order of the complete segment store.
160 public void testIterationOrder() {
162 for (ISegment segment
: fSegmentStore
) {
163 assertEquals(SEGMENTS
.get(i
++), segment
);
168 * Test the iteration order when the elements are not inserted in sorted
172 public void testIterationOrderNonSortedInsertion() {
173 /* Prepare the segment store, we don't use the 'fixture' in this test */
174 ISegmentStore
<@NonNull ISegment
> store
= getSegmentStore();
175 for (ISegment segment
: REVERSE_SEGMENTS
) {
176 store
.add(checkNotNull(segment
));
180 * Test each element one by one, the iteration order should follow the
181 * start times, not the insertion order.
184 for (ISegment segment
: store
) {
185 assertEquals(SEGMENTS
.get(i
++), segment
);
188 /* Manually dispose our own store */
194 * {@link ISegmentStore#getIntersectingElements(long start, long end)}
197 public void testGetIntersectingElementsRange() {
199 Iterable
<ISegment
> intersectingElements
;
202 * Range that does not include any segment
204 intersectingElements
= fSegmentStore
.getIntersectingElements(16, 20);
205 assertEquals(0, Iterables
.size(intersectingElements
));
208 * Range start time : Before first segment start time Range end time :
209 * After last segment end time
211 intersectingElements
= fSegmentStore
.getIntersectingElements(1, 15);
212 assertEquals(5, Iterables
.size(intersectingElements
));
215 * Range start time : On first segment start time Range end time : On
216 * last segment end time
218 intersectingElements
= fSegmentStore
.getIntersectingElements(2, 14);
219 assertEquals(5, Iterables
.size(intersectingElements
));
222 * Range start time : After one segment start time Range end time :
223 * Before one segment end time
225 intersectingElements
= fSegmentStore
.getIntersectingElements(11, 13);
226 assertEquals(1, Iterables
.size(intersectingElements
));
227 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
230 * Range start time : On one segment start time Range end time : On one
233 intersectingElements
= fSegmentStore
.getIntersectingElements(10, 14);
234 assertEquals(1, Iterables
.size(intersectingElements
));
235 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
238 * Range start time : On last segment end time Range end time : After
239 * last segment end time
241 intersectingElements
= fSegmentStore
.getIntersectingElements(14, 18);
242 assertEquals(1, Iterables
.size(intersectingElements
));
243 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
246 * Range start time : Before first segment start time Range end time :
247 * On first segment start time
249 intersectingElements
= fSegmentStore
.getIntersectingElements(1, 2);
250 assertEquals(1, Iterables
.size(intersectingElements
));
251 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
255 * Testing method {@link ISegmentStore#getIntersectingElements(long time)}
258 public void testGetIntersectingElementsTime() {
260 Iterable
<ISegment
> intersectingElements
;
263 * Time between segment start time and end time
265 intersectingElements
= fSegmentStore
.getIntersectingElements(3);
266 assertEquals(1, Iterables
.size(intersectingElements
));
267 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
270 * Time on segment start time
272 intersectingElements
= fSegmentStore
.getIntersectingElements(2);
273 assertEquals(1, Iterables
.size(intersectingElements
));
274 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
277 * Time on segment end time
279 intersectingElements
= fSegmentStore
.getIntersectingElements(14);
280 assertEquals(1, Iterables
.size(intersectingElements
));
281 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
284 * Time overlapping many segments
286 intersectingElements
= fSegmentStore
.getIntersectingElements(6);
287 assertEquals(4, Iterables
.size(intersectingElements
));
290 * Time between segments
292 intersectingElements
= fSegmentStore
.getIntersectingElements(9);
293 assertEquals(0, Iterables
.size(intersectingElements
));
296 * Time before all segment start time
298 intersectingElements
= fSegmentStore
.getIntersectingElements(1);
299 assertEquals(0, Iterables
.size(intersectingElements
));
302 * Time after all segment end time
304 intersectingElements
= fSegmentStore
.getIntersectingElements(15);
305 assertEquals(0, Iterables
.size(intersectingElements
));
309 * Testing method {@link ISegmentStore#dispose()}
312 public void testDispose() {
313 ISegmentStore
<@NonNull ISegment
> store
= getSegmentStore();
314 store
.add(SEGMENT_2_6
);
316 assertEquals(0, store
.size());
320 * Test iterating over a store being built.
325 public void testIterator() {
326 Collection
<@NonNull ISegment
> beforeExpected
= ImmutableList
.of(SEGMENT_2_6
);
327 Collection
<@NonNull ISegment
> afterExpected
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_8
);
328 Collection
<@NonNull ISegment
> lastExpected
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_8
, SEGMENT_6_8
);
329 Collection
<@NonNull ISegment
> fixture
= new ArrayList
<>();
330 ISegmentStore
<@NonNull ISegment
> store
= getSegmentStore();
332 // Add one segment to the segment store and iterate
333 store
.add(SEGMENT_2_6
);
334 for (ISegment item
: store
) {
337 assertEquals(beforeExpected
, fixture
);
339 // Add a second segment to the store and iterate
341 store
.add(SEGMENT_4_8
);
342 for (ISegment item
: store
) {
345 assertEquals(afterExpected
, fixture
);
349 Iterator
<@NonNull ISegment
> iter
= store
.iterator();
351 // Add a third segment to the store and iterate
352 store
.add(SEGMENT_6_8
);
353 Iterator
<@NonNull ISegment
> iter2
= store
.iterator();
356 // Make sure the first iterator take has only 2 elements and the second
358 while (iter
.hasNext()) {
359 fixture
.add(iter
.next());
361 assertEquals(afterExpected
, fixture
);
363 while (iter2
.hasNext()) {
364 fixture
.add(iter2
.next());
366 assertEquals(lastExpected
, fixture
);
370 * Test to check ordered iterators
373 public void testSortedIterator() {
374 List
<@NonNull Comparator
<ISegment
>> comparators
= new LinkedList
<>();
375 comparators
.add(SegmentComparators
.INTERVAL_END_COMPARATOR
);
376 comparators
.add(NonNullUtils
.checkNotNull(SegmentComparators
.INTERVAL_END_COMPARATOR
.reversed()));
377 comparators
.add(SegmentComparators
.INTERVAL_START_COMPARATOR
);
378 comparators
.add(NonNullUtils
.checkNotNull(SegmentComparators
.INTERVAL_START_COMPARATOR
.reversed()));
379 comparators
.add(SegmentComparators
.INTERVAL_LENGTH_COMPARATOR
);
380 comparators
.add(NonNullUtils
.checkNotNull(SegmentComparators
.INTERVAL_LENGTH_COMPARATOR
.reversed()));
382 Iterable
<ISegment
> iterable
;
383 for (Comparator
<ISegment
> comparator
: comparators
) {
384 iterable
= fSegmentStore
.iterator(comparator
);
385 verifySortedIterable(iterable
, 5, comparator
);
386 iterable
= fSegmentStore
.getIntersectingElements(5, comparator
);
387 verifySortedIterable(iterable
, 3, comparator
);
388 iterable
= fSegmentStore
.getIntersectingElements(7, 14, comparator
);
389 verifySortedIterable(iterable
, 3, comparator
);
393 private static void verifySortedIterable(Iterable
<ISegment
> iterable
, int expectedSize
, Comparator
<ISegment
> comparator
) {
395 assertEquals(expectedSize
, Iterables
.size(iterable
));
396 Iterator
<ISegment
> iterator
= iterable
.iterator();
398 ISegment prev
, current
= iterator
.next();
399 while (iterator
.hasNext()) {
401 current
= iterator
.next();
402 assertTrue(comparator
.compare(prev
, current
) <= 0);