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 import static org.junit.Assert.assertFalse;
  15 import static org.junit.Assert.assertTrue;
  16
  17 import java.util.Arrays;
  18 import java.util.List;
  19
  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;
  26
  27 import com.google.common.collect.ImmutableList;
  28 import com.google.common.collect.Iterables;
  29 import com.google.common.collect.Lists;
  30
  31 /**
  32  * Unit tests for intersecting elements in a TreeMapStore
  33  *
  34  * @author France Lapointe Nguyen
  35  */
  36 public class TreeMapStoreTest {
  37
  38     private TreeMapStore<ISegment> fSegmentStore;
  39
  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);
  45
  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);
  48
  49     /**
  50      * Initialize data (test vector) that will be tested
  51      */
  52     @Before
  53     public void setup() {
  54         fSegmentStore = new TreeMapStore<>();
  55         for (ISegment segment : SEGMENTS) {
  56             fSegmentStore.add(checkNotNull(segment));
  57         }
  58     }
  59
  60     /**
  61      * Dispose of the segment store
  62      */
  63     @After
  64     public void teardown() {
  65         fSegmentStore.dispose();
  66     }
  67
  68     /**
  69      * Testing method size()
  70      */
  71     @Test
  72     public void testSize() {
  73         assertEquals(SEGMENTS.size(), fSegmentStore.size());
  74     }
  75
  76     /**
  77      * Test the contains() method.
  78      */
  79     @Test
  80     public void testContains() {
  81         ISegment otherSegment = new BasicSegment(0, 20);
  82
  83         assertTrue(fSegmentStore.contains(SEGMENT_2_6));
  84         assertTrue(fSegmentStore.contains(SEGMENT_4_8));
  85         assertFalse(fSegmentStore.contains(otherSegment));
  86     }
  87
  88     /**
  89      * Test the toArray() method.
  90      */
  91     @Test
  92     public void testToObjectArray() {
  93         Object[] array = fSegmentStore.toArray();
  94
  95         assertEquals(SEGMENTS.size(), array.length);
  96         assertTrue(Arrays.asList(array).containsAll(SEGMENTS));
  97     }
  98
  99     /**
 100      * Test the toArray(T[]) method.
 101      */
 102     @Test
 103     public void testToSpecificArray() {
 104         ISegment[] array = fSegmentStore.toArray(new ISegment[0]);
 105
 106         assertEquals(SEGMENTS.size(), array.length);
 107         assertTrue(Arrays.asList(array).containsAll(SEGMENTS));
 108     }
 109
 110     /**
 111      * Test the toArray(T[]) method with a subtype of ISegment.
 112      */
 113     @Test
 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]);
 119
 120         assertEquals(1, array.length);
 121         assertTrue(Arrays.asList(array).contains(otherSegment));
 122
 123         tms2.dispose();
 124     }
 125
 126     /**
 127      * Try adding duplicate elements, they should be ignored
 128      */
 129     @Test
 130     public void testNoDuplicateElements() {
 131         for (ISegment segment : SEGMENTS) {
 132             fSegmentStore.add(new BasicSegment(segment.getStart(), segment.getEnd()));
 133         }
 134         assertEquals(SEGMENTS.size(), fSegmentStore.size());
 135     }
 136
 137     /**
 138      * Test the iteration order of the complete segment store.
 139      */
 140     @Test
 141     public void testIterationOrder() {
 142         int i = 0;
 143         for (ISegment segment : fSegmentStore) {
 144             assertEquals(SEGMENTS.get(i++), segment);
 145         }
 146     }
 147
 148     /**
 149      * Test the iteration order when the elements are not inserted in sorted
 150      * order.
 151      */
 152     @Test
 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));
 158         }
 159
 160         /*
 161          * Test each element one by one, the iteration order should follow the
 162          * start times, not the insertion order.
 163          */
 164         int i = 0;
 165         for (ISegment segment : store) {
 166             assertEquals(SEGMENTS.get(i++), segment);
 167         }
 168
 169         /* Manually dispose our own store */
 170         store.dispose();
 171     }
 172
 173     /**
 174      * Testing method getIntersectingElements(long start, long end)
 175      */
 176     @Test
 177     public void testGetIntersectingElementsRange() {
 178
 179         Iterable<ISegment> intersectingElements;
 180
 181         /*
 182          * Range that does not include any segment
 183          */
 184         intersectingElements = fSegmentStore.getIntersectingElements(16, 20);
 185         assertEquals(0, Iterables.size(intersectingElements));
 186
 187         /*
 188          * Range start time : Before first segment start time
 189          * Range end time : After last segment end time
 190          */
 191         intersectingElements = fSegmentStore.getIntersectingElements(1, 15);
 192         assertEquals(5, Iterables.size(intersectingElements));
 193
 194         /*
 195          * Range start time : On first segment start time
 196          * Range end time : On last segment end time
 197          */
 198         intersectingElements = fSegmentStore.getIntersectingElements(2, 14);
 199         assertEquals(5, Iterables.size(intersectingElements));
 200
 201         /*
 202          * Range start time : After one segment start time
 203          * Range end time : Before one segment end time
 204          */
 205         intersectingElements = fSegmentStore.getIntersectingElements(11, 13);
 206         assertEquals(1, Iterables.size(intersectingElements));
 207         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 208
 209         /*
 210          * Range start time : On one segment start time
 211          * Range end time : On one segment end time
 212          */
 213         intersectingElements = fSegmentStore.getIntersectingElements(10, 14);
 214         assertEquals(1, Iterables.size(intersectingElements));
 215         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 216
 217         /*
 218          * Range start time : On last segment end time
 219          * Range end time : After last segment end time
 220          */
 221         intersectingElements = fSegmentStore.getIntersectingElements(14, 18);
 222         assertEquals(1, Iterables.size(intersectingElements));
 223         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 224
 225         /*
 226          * Range start time : Before first segment start time
 227          * Range end time : On first segment start time
 228          */
 229         intersectingElements = fSegmentStore.getIntersectingElements(1, 2);
 230         assertEquals(1, Iterables.size(intersectingElements));
 231         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 232     }
 233
 234     /**
 235      * Testing method getIntersectingElements(long start, long end)
 236      */
 237     @Test
 238     public void testGetIntersectingElementsTime() {
 239
 240         Iterable<ISegment> intersectingElements;
 241
 242         /*
 243          * Time between segment start time and end time
 244          */
 245         intersectingElements = fSegmentStore.getIntersectingElements(3);
 246         assertEquals(1, Iterables.size(intersectingElements));
 247         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 248
 249         /*
 250          * Time on segment start time
 251          */
 252         intersectingElements = fSegmentStore.getIntersectingElements(2);
 253         assertEquals(1, Iterables.size(intersectingElements));
 254         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 255
 256         /*
 257          * Time on segment end time
 258          */
 259         intersectingElements = fSegmentStore.getIntersectingElements(14);
 260         assertEquals(1, Iterables.size(intersectingElements));
 261         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 262
 263         /*
 264          * Time overlapping many segments
 265          */
 266         intersectingElements = fSegmentStore.getIntersectingElements(6);
 267         assertEquals(4, Iterables.size(intersectingElements));
 268
 269         /*
 270          * Time between segments
 271          */
 272         intersectingElements = fSegmentStore.getIntersectingElements(9);
 273         assertEquals(0, Iterables.size(intersectingElements));
 274
 275         /*
 276          * Time before all segment start time
 277          */
 278         intersectingElements = fSegmentStore.getIntersectingElements(1);
 279         assertEquals(0, Iterables.size(intersectingElements));
 280
 281         /*
 282          * Time after all segment end time
 283          */
 284         intersectingElements = fSegmentStore.getIntersectingElements(15);
 285         assertEquals(0, Iterables.size(intersectingElements));
 286     }
 287
 288     /**
 289      * Testing method getIntersectingElements(long start, long end)
 290      */
 291     @Test
 292     public void testDispose() {
 293         TreeMapStore<ISegment> store = new TreeMapStore<>();
 294         store.add(SEGMENT_2_6);
 295         store.dispose();
 296         assertEquals(0, store.size());
 297     }
 298 }