1 /*******************************************************************************
2 * Copyright (c) 2015 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
.treemap
;
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
.Arrays
;
18 import java
.util
.List
;
20 import org
.eclipse
.tracecompass
.segmentstore
.core
.BasicSegment
;
21 import org
.eclipse
.tracecompass
.segmentstore
.core
.ISegment
;
22 import org
.eclipse
.tracecompass
.segmentstore
.core
.treemap
.TreeMapStore
;
23 import org
.junit
.After
;
24 import org
.junit
.Before
;
25 import org
.junit
.Test
;
27 import com
.google
.common
.collect
.ImmutableList
;
28 import com
.google
.common
.collect
.Iterables
;
29 import com
.google
.common
.collect
.Lists
;
32 * Unit tests for intersecting elements in a TreeMapStore
34 * @author France Lapointe Nguyen
36 public class TreeMapStoreTest
{
38 private TreeMapStore
<ISegment
> fSegmentStore
;
40 private static final ISegment SEGMENT_2_6
= new BasicSegment(2, 6);
41 private static final ISegment SEGMENT_4_6
= new BasicSegment(4, 6);
42 private static final ISegment SEGMENT_4_8
= new BasicSegment(4, 8);
43 private static final ISegment SEGMENT_6_8
= new BasicSegment(6, 8);
44 private static final ISegment SEGMENT_10_14
= new BasicSegment(10, 14);
46 private static final List
<ISegment
> SEGMENTS
= ImmutableList
.of(SEGMENT_2_6
, SEGMENT_4_6
, SEGMENT_4_8
, SEGMENT_6_8
, SEGMENT_10_14
);
47 private static final List
<ISegment
> REVERSE_SEGMENTS
= Lists
.reverse(SEGMENTS
);
50 * Initialize data (test vector) that will be tested
54 fSegmentStore
= new TreeMapStore
<>();
55 for (ISegment segment
: SEGMENTS
) {
56 fSegmentStore
.add(checkNotNull(segment
));
61 * Dispose of the segment store
64 public void teardown() {
65 fSegmentStore
.dispose();
69 * Testing method size()
72 public void testSize() {
73 assertEquals(SEGMENTS
.size(), fSegmentStore
.size());
77 * Test the contains() method.
80 public void testContains() {
81 ISegment otherSegment
= new BasicSegment(0, 20);
83 assertTrue(fSegmentStore
.contains(SEGMENT_2_6
));
84 assertTrue(fSegmentStore
.contains(SEGMENT_4_8
));
85 assertFalse(fSegmentStore
.contains(otherSegment
));
89 * Test the toArray() method.
92 public void testToObjectArray() {
93 Object
[] array
= fSegmentStore
.toArray();
95 assertEquals(SEGMENTS
.size(), array
.length
);
96 assertTrue(Arrays
.asList(array
).containsAll(SEGMENTS
));
100 * Test the toArray(T[]) method.
103 public void testToSpecificArray() {
104 ISegment
[] array
= fSegmentStore
.toArray(new ISegment
[0]);
106 assertEquals(SEGMENTS
.size(), array
.length
);
107 assertTrue(Arrays
.asList(array
).containsAll(SEGMENTS
));
111 * Test the toArray(T[]) method with a subtype of ISegment.
114 public void testToSpecifyArraySubtype() {
115 TreeMapStore
<BasicSegment
> tms2
= new TreeMapStore
<>();
116 BasicSegment otherSegment
= new BasicSegment(2, 6);
117 tms2
.add(otherSegment
);
118 BasicSegment
[] array
= tms2
.toArray(new BasicSegment
[0]);
120 assertEquals(1, array
.length
);
121 assertTrue(Arrays
.asList(array
).contains(otherSegment
));
127 * Try adding duplicate elements, they should be ignored
130 public void testNoDuplicateElements() {
131 for (ISegment segment
: SEGMENTS
) {
132 fSegmentStore
.add(new BasicSegment(segment
.getStart(), segment
.getEnd()));
134 assertEquals(SEGMENTS
.size(), fSegmentStore
.size());
138 * Test the iteration order of the complete segment store.
141 public void testIterationOrder() {
143 for (ISegment segment
: fSegmentStore
) {
144 assertEquals(SEGMENTS
.get(i
++), segment
);
149 * Test the iteration order when the elements are not inserted in sorted
153 public void testIterationOrderNonSortedInsertion() {
154 /* Prepare the segment store, we don't use the 'fixture' in this test */
155 TreeMapStore
<ISegment
> store
= new TreeMapStore
<>();
156 for (ISegment segment
: REVERSE_SEGMENTS
) {
157 store
.add(checkNotNull(segment
));
161 * Test each element one by one, the iteration order should follow the
162 * start times, not the insertion order.
165 for (ISegment segment
: store
) {
166 assertEquals(SEGMENTS
.get(i
++), segment
);
169 /* Manually dispose our own store */
174 * Testing method getIntersectingElements(long start, long end)
177 public void testGetIntersectingElementsRange() {
179 Iterable
<ISegment
> intersectingElements
;
182 * Range that does not include any segment
184 intersectingElements
= fSegmentStore
.getIntersectingElements(16, 20);
185 assertEquals(0, Iterables
.size(intersectingElements
));
188 * Range start time : Before first segment start time
189 * Range end time : After last segment end time
191 intersectingElements
= fSegmentStore
.getIntersectingElements(1, 15);
192 assertEquals(5, Iterables
.size(intersectingElements
));
195 * Range start time : On first segment start time
196 * Range end time : On last segment end time
198 intersectingElements
= fSegmentStore
.getIntersectingElements(2, 14);
199 assertEquals(5, Iterables
.size(intersectingElements
));
202 * Range start time : After one segment start time
203 * Range end time : Before one segment end time
205 intersectingElements
= fSegmentStore
.getIntersectingElements(11, 13);
206 assertEquals(1, Iterables
.size(intersectingElements
));
207 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
210 * Range start time : On one segment start time
211 * Range end time : On one segment end time
213 intersectingElements
= fSegmentStore
.getIntersectingElements(10, 14);
214 assertEquals(1, Iterables
.size(intersectingElements
));
215 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
218 * Range start time : On last segment end time
219 * Range end time : After last segment end time
221 intersectingElements
= fSegmentStore
.getIntersectingElements(14, 18);
222 assertEquals(1, Iterables
.size(intersectingElements
));
223 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
226 * Range start time : Before first segment start time
227 * Range end time : On first segment start time
229 intersectingElements
= fSegmentStore
.getIntersectingElements(1, 2);
230 assertEquals(1, Iterables
.size(intersectingElements
));
231 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
235 * Testing method getIntersectingElements(long start, long end)
238 public void testGetIntersectingElementsTime() {
240 Iterable
<ISegment
> intersectingElements
;
243 * Time between segment start time and end time
245 intersectingElements
= fSegmentStore
.getIntersectingElements(3);
246 assertEquals(1, Iterables
.size(intersectingElements
));
247 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
250 * Time on segment start time
252 intersectingElements
= fSegmentStore
.getIntersectingElements(2);
253 assertEquals(1, Iterables
.size(intersectingElements
));
254 assertEquals(SEGMENT_2_6
, Iterables
.getOnlyElement(intersectingElements
));
257 * Time on segment end time
259 intersectingElements
= fSegmentStore
.getIntersectingElements(14);
260 assertEquals(1, Iterables
.size(intersectingElements
));
261 assertEquals(SEGMENT_10_14
, Iterables
.getOnlyElement(intersectingElements
));
264 * Time overlapping many segments
266 intersectingElements
= fSegmentStore
.getIntersectingElements(6);
267 assertEquals(4, Iterables
.size(intersectingElements
));
270 * Time between segments
272 intersectingElements
= fSegmentStore
.getIntersectingElements(9);
273 assertEquals(0, Iterables
.size(intersectingElements
));
276 * Time before all segment start time
278 intersectingElements
= fSegmentStore
.getIntersectingElements(1);
279 assertEquals(0, Iterables
.size(intersectingElements
));
282 * Time after all segment end time
284 intersectingElements
= fSegmentStore
.getIntersectingElements(15);
285 assertEquals(0, Iterables
.size(intersectingElements
));
289 * Testing method getIntersectingElements(long start, long end)
292 public void testDispose() {
293 TreeMapStore
<ISegment
> store
= new TreeMapStore
<>();
294 store
.add(SEGMENT_2_6
);
296 assertEquals(0, store
.size());