package org.eclipse.tracecompass.segmentstore.core.tests.treemap;
+import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import java.util.Arrays;
import java.util.List;
-import org.eclipse.tracecompass.common.core.NonNullUtils;
import org.eclipse.tracecompass.segmentstore.core.BasicSegment;
import org.eclipse.tracecompass.segmentstore.core.ISegment;
import org.eclipse.tracecompass.segmentstore.core.treemap.TreeMapStore;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
/**
* Unit tests for intersecting elements in a TreeMapStore
private TreeMapStore<ISegment> fSegmentStore;
- private static final ISegment SEGMENT_2_4 = new BasicSegment(2, 4);
+ private static final ISegment SEGMENT_2_6 = new BasicSegment(2, 6);
+ private static final ISegment SEGMENT_4_6 = new BasicSegment(4, 6);
+ private static final ISegment SEGMENT_4_8 = new BasicSegment(4, 8);
private static final ISegment SEGMENT_6_8 = new BasicSegment(6, 8);
private static final ISegment SEGMENT_10_14 = new BasicSegment(10, 14);
- private static final List<ISegment> SEGMENTS = ImmutableList.of(SEGMENT_2_4, SEGMENT_6_8, SEGMENT_10_14);
+ private static final List<ISegment> SEGMENTS = ImmutableList.of(SEGMENT_2_6, SEGMENT_4_6, SEGMENT_4_8, SEGMENT_6_8, SEGMENT_10_14);
+ private static final List<ISegment> REVERSE_SEGMENTS = Lists.reverse(SEGMENTS);
/**
* Initialize data (test vector) that will be tested
@Before
public void setup() {
fSegmentStore = new TreeMapStore<>();
- for (int i = 0; i < SEGMENTS.size(); i++) {
- fSegmentStore.addElement(NonNullUtils.checkNotNull(SEGMENTS.get(i)));
+ for (ISegment segment : SEGMENTS) {
+ fSegmentStore.add(checkNotNull(segment));
}
}
}
/**
- * Testing method getNbElements
+ * Testing method size()
*/
@Test
- public void testGetNbElements() {
- assertEquals(SEGMENTS.size(), fSegmentStore.getNbElements());
+ public void testSize() {
+ assertEquals(SEGMENTS.size(), fSegmentStore.size());
}
/**
- * Testing method getElementAtIndex
+ * Test the contains() method.
*/
@Test
- public void testGetElementAtIndex() {
- for (int i = 0; i < SEGMENTS.size(); i++) {
- assertEquals(SEGMENTS.get(i), fSegmentStore.getElementAtIndex(i));
+ public void testContains() {
+ ISegment otherSegment = new BasicSegment(0, 20);
+
+ assertTrue(fSegmentStore.contains(SEGMENT_2_6));
+ assertTrue(fSegmentStore.contains(SEGMENT_4_8));
+ assertFalse(fSegmentStore.contains(otherSegment));
+ }
+
+ /**
+ * Test the toArray() method.
+ */
+ @Test
+ public void testToObjectArray() {
+ Object[] array = fSegmentStore.toArray();
+
+ assertEquals(SEGMENTS.size(), array.length);
+ assertTrue(Arrays.asList(array).containsAll(SEGMENTS));
+ }
+
+ /**
+ * Test the toArray(T[]) method.
+ */
+ @Test
+ public void testToSpecificArray() {
+ ISegment[] array = fSegmentStore.toArray(new ISegment[0]);
+
+ assertEquals(SEGMENTS.size(), array.length);
+ assertTrue(Arrays.asList(array).containsAll(SEGMENTS));
+ }
+
+ /**
+ * Test the toArray(T[]) method with a subtype of ISegment.
+ */
+ @Test
+ public void testToSpecifyArraySubtype() {
+ TreeMapStore<BasicSegment> tms2 = new TreeMapStore<>();
+ BasicSegment otherSegment = new BasicSegment(2, 6);
+ tms2.add(otherSegment);
+ BasicSegment[] array = tms2.toArray(new BasicSegment[0]);
+
+ assertEquals(1, array.length);
+ assertTrue(Arrays.asList(array).contains(otherSegment));
+
+ tms2.dispose();
+ }
+
+ /**
+ * Try adding duplicate elements, they should be ignored
+ */
+ @Test
+ public void testNoDuplicateElements() {
+ for (ISegment segment : SEGMENTS) {
+ fSegmentStore.add(new BasicSegment(segment.getStart(), segment.getEnd()));
}
+ assertEquals(SEGMENTS.size(), fSegmentStore.size());
+ }
+
+ /**
+ * Test the iteration order of the complete segment store.
+ */
+ @Test
+ public void testIterationOrder() {
+ int i = 0;
+ for (ISegment segment : fSegmentStore) {
+ assertEquals(SEGMENTS.get(i++), segment);
+ }
+ }
+
+ /**
+ * Test the iteration order when the elements are not inserted in sorted
+ * order.
+ */
+ @Test
+ public void testIterationOrderNonSortedInsertion() {
+ /* Prepare the segment store, we don't use the 'fixture' in this test */
+ TreeMapStore<ISegment> store = new TreeMapStore<>();
+ for (ISegment segment : REVERSE_SEGMENTS) {
+ store.add(checkNotNull(segment));
+ }
+
+ /*
+ * Test each element one by one, the iteration order should follow the
+ * start times, not the insertion order.
+ */
+ int i = 0;
+ for (ISegment segment : store) {
+ assertEquals(SEGMENTS.get(i++), segment);
+ }
+
+ /* Manually dispose our own store */
+ store.dispose();
}
/**
assertEquals(0, Iterables.size(intersectingElements));
/*
- * Range start time : Before first segment start time Range end time :
- * After last segment end time
+ * Range start time : Before first segment start time
+ * Range end time : After last segment end time
*/
intersectingElements = fSegmentStore.getIntersectingElements(1, 15);
- assertEquals(3, Iterables.size(intersectingElements));
+ assertEquals(5, Iterables.size(intersectingElements));
/*
- * Range start time : On first segment start time Range end time : On
- * last segment end time
+ * Range start time : On first segment start time
+ * Range end time : On last segment end time
*/
intersectingElements = fSegmentStore.getIntersectingElements(2, 14);
- assertEquals(3, Iterables.size(intersectingElements));
+ assertEquals(5, Iterables.size(intersectingElements));
/*
- * Range start time : After one segment start time Range end time :
- * Before one segment end time
+ * Range start time : After one segment start time
+ * Range end time : Before one segment end time
*/
intersectingElements = fSegmentStore.getIntersectingElements(11, 13);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_10_14.equals(intersectingElements));
+ assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
/*
- * Range start time : On one segment start time Range end time : On one
- * segment end time
+ * Range start time : On one segment start time
+ * Range end time : On one segment end time
*/
- intersectingElements = fSegmentStore.getIntersectingElements(6, 8);
+ intersectingElements = fSegmentStore.getIntersectingElements(10, 14);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_6_8.equals(intersectingElements));
+ assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
/*
- * Range start time : On last segment end time Range end time : After
- * last segment end time
+ * Range start time : On last segment end time
+ * Range end time : After last segment end time
*/
intersectingElements = fSegmentStore.getIntersectingElements(14, 18);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_10_14.equals(intersectingElements));
+ assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
/*
- * Range start time : Before first segment start time Range end time :
- * On first segment start time
+ * Range start time : Before first segment start time
+ * Range end time : On first segment start time
*/
intersectingElements = fSegmentStore.getIntersectingElements(1, 2);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_2_4.equals(intersectingElements));
+ assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
}
/**
*/
intersectingElements = fSegmentStore.getIntersectingElements(3);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_2_4.equals(intersectingElements));
+ assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
/*
* Time on segment start time
*/
intersectingElements = fSegmentStore.getIntersectingElements(2);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_2_4.equals(intersectingElements));
+ assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
/*
* Time on segment end time
*/
- intersectingElements = fSegmentStore.getIntersectingElements(4);
+ intersectingElements = fSegmentStore.getIntersectingElements(14);
assertEquals(1, Iterables.size(intersectingElements));
- assert (SEGMENT_2_4.equals(intersectingElements));
+ assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
+
+ /*
+ * Time overlapping many segments
+ */
+ intersectingElements = fSegmentStore.getIntersectingElements(6);
+ assertEquals(4, Iterables.size(intersectingElements));
+
+ /*
+ * Time between segments
+ */
+ intersectingElements = fSegmentStore.getIntersectingElements(9);
+ assertEquals(0, Iterables.size(intersectingElements));
/*
* Time before all segment start time
@Test
public void testDispose() {
TreeMapStore<ISegment> store = new TreeMapStore<>();
- store.addElement(NonNullUtils.checkNotNull(SEGMENT_2_4));
+ store.add(SEGMENT_2_6);
store.dispose();
- assertEquals(0, store.getNbElements());
+ assertEquals(0, store.size());
}
}
\ No newline at end of file
projects / deliverable / tracecompass.git / blobdiff