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.junit.Assert.assertEquals;
  13
  14 import java.util.List;
  15
  16 import org.eclipse.tracecompass.common.core.NonNullUtils;
  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
  27 /**
  28  * Unit tests for intersecting elements in a TreeMapStore
  29  *
  30  * @author France Lapointe Nguyen
  31  */
  32 public class TreeMapStoreTest {
  33
  34     private TreeMapStore<ISegment> fSegmentStore;
  35
  36     private static final ISegment SEGMENT_2_4 = new BasicSegment(2, 4);
  37     private static final ISegment SEGMENT_6_8 = new BasicSegment(6, 8);
  38     private static final ISegment SEGMENT_10_14 = new BasicSegment(10, 14);
  39
  40     private static final List<ISegment> SEGMENTS = ImmutableList.of(SEGMENT_2_4, SEGMENT_6_8, SEGMENT_10_14);
  41
  42     /**
  43      * Initialize data (test vector) that will be tested
  44      */
  45     @Before
  46     public void setup() {
  47         fSegmentStore = new TreeMapStore<>();
  48         for (int i = 0; i < SEGMENTS.size(); i++) {
  49             fSegmentStore.addElement(NonNullUtils.checkNotNull(SEGMENTS.get(i)));
  50         }
  51     }
  52
  53     /**
  54      * Dispose of the segment store
  55      */
  56     @After
  57     public void teardown() {
  58         fSegmentStore.dispose();
  59     }
  60
  61     /**
  62      * Testing method getNbElements
  63      */
  64     @Test
  65     public void testGetNbElements() {
  66         assertEquals(SEGMENTS.size(), fSegmentStore.getNbElements());
  67     }
  68
  69     /**
  70      * Testing method getElementAtIndex
  71      */
  72     @Test
  73     public void testGetElementAtIndex() {
  74         for (int i = 0; i < SEGMENTS.size(); i++) {
  75             assertEquals(SEGMENTS.get(i), fSegmentStore.getElementAtIndex(i));
  76         }
  77     }
  78
  79     /**
  80      * Testing method getIntersectingElements(long start, long end)
  81      */
  82     @Test
  83     public void testGetIntersectingElementsRange() {
  84
  85         Iterable<ISegment> intersectingElements;
  86
  87         /*
  88          * Range that does not include any segment
  89          */
  90         intersectingElements = fSegmentStore.getIntersectingElements(16, 20);
  91         assertEquals(0, Iterables.size(intersectingElements));
  92
  93         /*
  94          * Range start time : Before first segment start time Range end time :
  95          * After last segment end time
  96          */
  97         intersectingElements = fSegmentStore.getIntersectingElements(1, 15);
  98         assertEquals(3, Iterables.size(intersectingElements));
  99
 100         /*
 101          * Range start time : On first segment start time Range end time : On
 102          * last segment end time
 103          */
 104         intersectingElements = fSegmentStore.getIntersectingElements(2, 14);
 105         assertEquals(3, Iterables.size(intersectingElements));
 106
 107         /*
 108          * Range start time : After one segment start time Range end time :
 109          * Before one segment end time
 110          */
 111         intersectingElements = fSegmentStore.getIntersectingElements(11, 13);
 112         assertEquals(1, Iterables.size(intersectingElements));
 113         assert (SEGMENT_10_14.equals(intersectingElements));
 114
 115         /*
 116          * Range start time : On one segment start time Range end time : On one
 117          * segment end time
 118          */
 119         intersectingElements = fSegmentStore.getIntersectingElements(6, 8);
 120         assertEquals(1, Iterables.size(intersectingElements));
 121         assert (SEGMENT_6_8.equals(intersectingElements));
 122
 123         /*
 124          * Range start time : On last segment end time Range end time : After
 125          * last segment end time
 126          */
 127         intersectingElements = fSegmentStore.getIntersectingElements(14, 18);
 128         assertEquals(1, Iterables.size(intersectingElements));
 129         assert (SEGMENT_10_14.equals(intersectingElements));
 130
 131         /*
 132          * Range start time : Before first segment start time Range end time :
 133          * On first segment start time
 134          */
 135         intersectingElements = fSegmentStore.getIntersectingElements(1, 2);
 136         assertEquals(1, Iterables.size(intersectingElements));
 137         assert (SEGMENT_2_4.equals(intersectingElements));
 138     }
 139
 140     /**
 141      * Testing method getIntersectingElements(long start, long end)
 142      */
 143     @Test
 144     public void testGetIntersectingElementsTime() {
 145
 146         Iterable<ISegment> intersectingElements;
 147
 148         /*
 149          * Time between segment start time and end time
 150          */
 151         intersectingElements = fSegmentStore.getIntersectingElements(3);
 152         assertEquals(1, Iterables.size(intersectingElements));
 153         assert (SEGMENT_2_4.equals(intersectingElements));
 154
 155         /*
 156          * Time on segment start time
 157          */
 158         intersectingElements = fSegmentStore.getIntersectingElements(2);
 159         assertEquals(1, Iterables.size(intersectingElements));
 160         assert (SEGMENT_2_4.equals(intersectingElements));
 161
 162         /*
 163          * Time on segment end time
 164          */
 165         intersectingElements = fSegmentStore.getIntersectingElements(4);
 166         assertEquals(1, Iterables.size(intersectingElements));
 167         assert (SEGMENT_2_4.equals(intersectingElements));
 168
 169         /*
 170          * Time before all segment start time
 171          */
 172         intersectingElements = fSegmentStore.getIntersectingElements(1);
 173         assertEquals(0, Iterables.size(intersectingElements));
 174
 175         /*
 176          * Time after all segment end time
 177          */
 178         intersectingElements = fSegmentStore.getIntersectingElements(15);
 179         assertEquals(0, Iterables.size(intersectingElements));
 180     }
 181
 182     /**
 183      * Testing method getIntersectingElements(long start, long end)
 184      */
 185     @Test
 186     public void testDispose() {
 187         TreeMapStore<ISegment> store = new TreeMapStore<>();
 188         store.addElement(NonNullUtils.checkNotNull(SEGMENT_2_4));
 189         store.dispose();
 190         assertEquals(0, store.getNbElements());
 191     }
 192 }