statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/treemap/TreeMapStoreTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2015 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
  10 package org.eclipse.tracecompass.segmentstore.core.tests.treemap;
  11
  12 import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
  13 import static org.junit.Assert.assertEquals;
  14
  15 import java.util.List;
  16
  17 import org.eclipse.tracecompass.segmentstore.core.BasicSegment;
  18 import org.eclipse.tracecompass.segmentstore.core.ISegment;
  19 import org.eclipse.tracecompass.segmentstore.core.treemap.TreeMapStore;
  20 import org.junit.After;
  21 import org.junit.Before;
  22 import org.junit.Test;
  23
  24 import com.google.common.collect.ImmutableList;
  25 import com.google.common.collect.Iterables;
  26 import com.google.common.collect.Lists;
  27
  28 /**
  29  * Unit tests for intersecting elements in a TreeMapStore
  30  *
  31  * @author France Lapointe Nguyen
  32  */
  33 public class TreeMapStoreTest {
  34
  35     private TreeMapStore<ISegment> fSegmentStore;
  36
  37     private static final ISegment SEGMENT_2_6 = new BasicSegment(2, 6);
  38     private static final ISegment SEGMENT_4_6 = new BasicSegment(4, 6);
  39     private static final ISegment SEGMENT_4_8 = new BasicSegment(4, 8);
  40     private static final ISegment SEGMENT_6_8 = new BasicSegment(6, 8);
  41     private static final ISegment SEGMENT_10_14 = new BasicSegment(10, 14);
  42
  43     private static final List<ISegment> SEGMENTS = ImmutableList.of(SEGMENT_2_6, SEGMENT_4_6, SEGMENT_4_8, SEGMENT_6_8, SEGMENT_10_14);
  44     private static final List<ISegment> REVERSE_SEGMENTS = Lists.reverse(SEGMENTS);
  45
  46     /**
  47      * Initialize data (test vector) that will be tested
  48      */
  49     @Before
  50     public void setup() {
  51         fSegmentStore = new TreeMapStore<>();
  52         for (ISegment segment : SEGMENTS) {
  53             fSegmentStore.addElement(checkNotNull(segment));
  54         }
  55     }
  56
  57     /**
  58      * Dispose of the segment store
  59      */
  60     @After
  61     public void teardown() {
  62         fSegmentStore.dispose();
  63     }
  64
  65     /**
  66      * Testing method getNbElements
  67      */
  68     @Test
  69     public void testGetNbElements() {
  70         assertEquals(SEGMENTS.size(), fSegmentStore.getNbElements());
  71     }
  72
  73     /**
  74      * Try adding duplicate elements, they should be ignored
  75      */
  76     @Test
  77     public void testNoDuplicateElements() {
  78         for (ISegment segment : SEGMENTS) {
  79             fSegmentStore.addElement(new BasicSegment(segment.getStart(), segment.getEnd()));
  80         }
  81         assertEquals(SEGMENTS.size(), fSegmentStore.getNbElements());
  82     }
  83
  84     /**
  85      * Test the iteration order of the complete segment store.
  86      */
  87     @Test
  88     public void testIterationOrder() {
  89         int i = 0;
  90         for (ISegment segment : fSegmentStore) {
  91             assertEquals(SEGMENTS.get(i++), segment);
  92         }
  93     }
  94
  95     /**
  96      * Test the iteration order when the elements are not inserted in sorted
  97      * order.
  98      */
  99     @Test
 100     public void testIterationOrderNonSortedInsertion() {
 101         /* Prepare the segment store, we don't use the 'fixture' in this test */
 102         TreeMapStore<ISegment> store = new TreeMapStore<>();
 103         for (ISegment segment : REVERSE_SEGMENTS) {
 104             store.addElement(checkNotNull(segment));
 105         }
 106
 107         /*
 108          * Test each element one by one, the iteration order should follow the
 109          * start times, not the insertion order.
 110          */
 111         int i = 0;
 112         for (ISegment segment : store) {
 113             assertEquals(SEGMENTS.get(i++), segment);
 114         }
 115
 116         /* Manually dispose our own store */
 117         store.dispose();
 118     }
 119
 120     /**
 121      * Testing method getIntersectingElements(long start, long end)
 122      */
 123     @Test
 124     public void testGetIntersectingElementsRange() {
 125
 126         Iterable<ISegment> intersectingElements;
 127
 128         /*
 129          * Range that does not include any segment
 130          */
 131         intersectingElements = fSegmentStore.getIntersectingElements(16, 20);
 132         assertEquals(0, Iterables.size(intersectingElements));
 133
 134         /*
 135          * Range start time : Before first segment start time
 136          * Range end time : After last segment end time
 137          */
 138         intersectingElements = fSegmentStore.getIntersectingElements(1, 15);
 139         assertEquals(5, Iterables.size(intersectingElements));
 140
 141         /*
 142          * Range start time : On first segment start time
 143          * Range end time : On last segment end time
 144          */
 145         intersectingElements = fSegmentStore.getIntersectingElements(2, 14);
 146         assertEquals(5, Iterables.size(intersectingElements));
 147
 148         /*
 149          * Range start time : After one segment start time
 150          * Range end time : Before one segment end time
 151          */
 152         intersectingElements = fSegmentStore.getIntersectingElements(11, 13);
 153         assertEquals(1, Iterables.size(intersectingElements));
 154         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 155
 156         /*
 157          * Range start time : On one segment start time
 158          * Range end time : On one segment end time
 159          */
 160         intersectingElements = fSegmentStore.getIntersectingElements(10, 14);
 161         assertEquals(1, Iterables.size(intersectingElements));
 162         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 163
 164         /*
 165          * Range start time : On last segment end time
 166          * Range end time : After last segment end time
 167          */
 168         intersectingElements = fSegmentStore.getIntersectingElements(14, 18);
 169         assertEquals(1, Iterables.size(intersectingElements));
 170         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 171
 172         /*
 173          * Range start time : Before first segment start time
 174          * Range end time : On first segment start time
 175          */
 176         intersectingElements = fSegmentStore.getIntersectingElements(1, 2);
 177         assertEquals(1, Iterables.size(intersectingElements));
 178         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 179     }
 180
 181     /**
 182      * Testing method getIntersectingElements(long start, long end)
 183      */
 184     @Test
 185     public void testGetIntersectingElementsTime() {
 186
 187         Iterable<ISegment> intersectingElements;
 188
 189         /*
 190          * Time between segment start time and end time
 191          */
 192         intersectingElements = fSegmentStore.getIntersectingElements(3);
 193         assertEquals(1, Iterables.size(intersectingElements));
 194         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 195
 196         /*
 197          * Time on segment start time
 198          */
 199         intersectingElements = fSegmentStore.getIntersectingElements(2);
 200         assertEquals(1, Iterables.size(intersectingElements));
 201         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 202
 203         /*
 204          * Time on segment end time
 205          */
 206         intersectingElements = fSegmentStore.getIntersectingElements(14);
 207         assertEquals(1, Iterables.size(intersectingElements));
 208         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 209
 210         /*
 211          * Time overlapping many segments
 212          */
 213         intersectingElements = fSegmentStore.getIntersectingElements(6);
 214         assertEquals(4, Iterables.size(intersectingElements));
 215
 216         /*
 217          * Time between segments
 218          */
 219         intersectingElements = fSegmentStore.getIntersectingElements(9);
 220         assertEquals(0, Iterables.size(intersectingElements));
 221
 222         /*
 223          * Time before all segment start time
 224          */
 225         intersectingElements = fSegmentStore.getIntersectingElements(1);
 226         assertEquals(0, Iterables.size(intersectingElements));
 227
 228         /*
 229          * Time after all segment end time
 230          */
 231         intersectingElements = fSegmentStore.getIntersectingElements(15);
 232         assertEquals(0, Iterables.size(intersectingElements));
 233     }
 234
 235     /**
 236      * Testing method getIntersectingElements(long start, long end)
 237      */
 238     @Test
 239     public void testDispose() {
 240         TreeMapStore<ISegment> store = new TreeMapStore<>();
 241         store.addElement(checkNotNull(SEGMENT_2_6));
 242         store.dispose();
 243         assertEquals(0, store.getNbElements());
 244     }
 245 }