statesystem/org.eclipse.tracecompass.segmentstore.core.tests/src/org/eclipse/tracecompass/segmentstore/core/tests/AbstractTestSegmentStore.java

   1 /*******************************************************************************
   2  * Copyright (c) 2016 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;
  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.ArrayList;
  18 import java.util.Arrays;
  19 import java.util.Collection;
  20 import java.util.Iterator;
  21 import java.util.List;
  22
  23 import org.eclipse.jdt.annotation.NonNull;
  24 import org.eclipse.tracecompass.segmentstore.core.BasicSegment;
  25 import org.eclipse.tracecompass.segmentstore.core.ISegment;
  26 import org.eclipse.tracecompass.segmentstore.core.ISegmentStore;
  27 import org.junit.After;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30
  31 import com.google.common.collect.ImmutableList;
  32 import com.google.common.collect.Iterables;
  33 import com.google.common.collect.Lists;
  34
  35 /**
  36  * Unit tests for intersecting elements in an SegmentStore
  37  *
  38  * Originally the TreeMapStoreTest, copied for this internal implementation. The
  39  * test was barely changed as it tests the interface and not the internals.
  40  *
  41  * @author Matthew Khouzam
  42  */
  43 public abstract class AbstractTestSegmentStore {
  44
  45     /**
  46      * The segment store
  47      */
  48     protected ISegmentStore<@NonNull ISegment> fSegmentStore;
  49
  50     /**
  51      * Get the segment store to test
  52      *
  53      * @return the segment store
  54      */
  55     protected abstract ISegmentStore<@NonNull ISegment> getSegmentStore();
  56
  57     private static final @NonNull ISegment SEGMENT_2_6 = new BasicSegment(2, 6);
  58     private static final @NonNull ISegment SEGMENT_4_6 = new BasicSegment(4, 6);
  59     private static final @NonNull ISegment SEGMENT_4_8 = new BasicSegment(4, 8);
  60     private static final @NonNull ISegment SEGMENT_6_8 = new BasicSegment(6, 8);
  61     private static final @NonNull ISegment SEGMENT_10_14 = new BasicSegment(10, 14);
  62     /**
  63      * A sample segment list
  64      */
  65     protected static final List<@NonNull ISegment> SEGMENTS = ImmutableList.of(SEGMENT_2_6, SEGMENT_4_6, SEGMENT_4_8, SEGMENT_6_8, SEGMENT_10_14);
  66     private static final List<@NonNull ISegment> REVERSE_SEGMENTS = Lists.reverse(SEGMENTS);
  67
  68     /**
  69      * Constructor
  70      */
  71     public AbstractTestSegmentStore() {
  72         super();
  73     }
  74
  75     /**
  76      * Initialize data (test vector) that will be tested
  77      */
  78     @Before
  79     public void setup() {
  80         fSegmentStore = getSegmentStore();
  81         for (ISegment segment : SEGMENTS) {
  82             fSegmentStore.add(segment);
  83         }
  84     }
  85
  86     /**
  87      * Dispose of the segment store
  88      */
  89     @After
  90     public void teardown() {
  91         fSegmentStore.dispose();
  92     }
  93
  94     /**
  95      * Testing method size()
  96      */
  97     @Test
  98     public void testSize() {
  99         assertEquals(SEGMENTS.size(), fSegmentStore.size());
 100     }
 101
 102     /**
 103      * Test the contains() method.
 104      */
 105     @Test
 106     public void testContains() {
 107         ISegment otherSegment = new BasicSegment(0, 20);
 108
 109         assertTrue(fSegmentStore.contains(SEGMENT_2_6));
 110         assertTrue(fSegmentStore.contains(SEGMENT_4_8));
 111         assertFalse(fSegmentStore.contains(otherSegment));
 112     }
 113
 114     /**
 115      * Test the toArray() method.
 116      */
 117     @Test
 118     public void testToObjectArray() {
 119         Object[] array = fSegmentStore.toArray();
 120
 121         assertEquals(SEGMENTS.size(), array.length);
 122         assertTrue(Arrays.asList(array).containsAll(SEGMENTS));
 123     }
 124
 125     /**
 126      * Test the toArray(T[]) method.
 127      */
 128     @Test
 129     public void testToSpecificArray() {
 130         ISegment[] array = fSegmentStore.toArray(new ISegment[0]);
 131
 132         assertEquals(SEGMENTS.size(), array.length);
 133         assertTrue(Arrays.asList(array).containsAll(SEGMENTS));
 134     }
 135
 136     /**
 137      * Test the toArray(T[]) method with a subtype of ISegment.
 138      */
 139     @Test
 140     public void testToSpecifyArraySubtype() {
 141         ISegmentStore<@NonNull ISegment> tms2 = getSegmentStore();
 142         BasicSegment otherSegment = new BasicSegment(2, 6);
 143         tms2.add(otherSegment);
 144         BasicSegment[] array = tms2.toArray(new BasicSegment[0]);
 145
 146         assertEquals(1, array.length);
 147         assertTrue(Arrays.asList(array).contains(otherSegment));
 148
 149         tms2.dispose();
 150     }
 151
 152     /**
 153      * Test the iteration order of the complete segment store.
 154      */
 155     @Test
 156     public void testIterationOrder() {
 157         int i = 0;
 158         for (ISegment segment : fSegmentStore) {
 159             assertEquals(SEGMENTS.get(i++), segment);
 160         }
 161     }
 162
 163     /**
 164      * Test the iteration order when the elements are not inserted in sorted
 165      * order.
 166      */
 167     @Test
 168     public void testIterationOrderNonSortedInsertion() {
 169         /* Prepare the segment store, we don't use the 'fixture' in this test */
 170         ISegmentStore<@NonNull ISegment> store = getSegmentStore();
 171         for (ISegment segment : REVERSE_SEGMENTS) {
 172             store.add(checkNotNull(segment));
 173         }
 174
 175         /*
 176          * Test each element one by one, the iteration order should follow the
 177          * start times, not the insertion order.
 178          */
 179         int i = 0;
 180         for (ISegment segment : store) {
 181             assertEquals(SEGMENTS.get(i++), segment);
 182         }
 183
 184         /* Manually dispose our own store */
 185         store.dispose();
 186     }
 187
 188     /**
 189      * Testing method
 190      * {@link ISegmentStore#getIntersectingElements(long start, long end)}
 191      */
 192     @Test
 193     public void testGetIntersectingElementsRange() {
 194
 195         Iterable<ISegment> intersectingElements;
 196
 197         /*
 198          * Range that does not include any segment
 199          */
 200         intersectingElements = fSegmentStore.getIntersectingElements(16, 20);
 201         assertEquals(0, Iterables.size(intersectingElements));
 202
 203         /*
 204          * Range start time : Before first segment start time Range end time :
 205          * After last segment end time
 206          */
 207         intersectingElements = fSegmentStore.getIntersectingElements(1, 15);
 208         assertEquals(5, Iterables.size(intersectingElements));
 209
 210         /*
 211          * Range start time : On first segment start time Range end time : On
 212          * last segment end time
 213          */
 214         intersectingElements = fSegmentStore.getIntersectingElements(2, 14);
 215         assertEquals(5, Iterables.size(intersectingElements));
 216
 217         /*
 218          * Range start time : After one segment start time Range end time :
 219          * Before one segment end time
 220          */
 221         intersectingElements = fSegmentStore.getIntersectingElements(11, 13);
 222         assertEquals(1, Iterables.size(intersectingElements));
 223         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 224
 225         /*
 226          * Range start time : On one segment start time Range end time : On one
 227          * segment end time
 228          */
 229         intersectingElements = fSegmentStore.getIntersectingElements(10, 14);
 230         assertEquals(1, Iterables.size(intersectingElements));
 231         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 232
 233         /*
 234          * Range start time : On last segment end time Range end time : After
 235          * last segment end time
 236          */
 237         intersectingElements = fSegmentStore.getIntersectingElements(14, 18);
 238         assertEquals(1, Iterables.size(intersectingElements));
 239         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 240
 241         /*
 242          * Range start time : Before first segment start time Range end time :
 243          * On first segment start time
 244          */
 245         intersectingElements = fSegmentStore.getIntersectingElements(1, 2);
 246         assertEquals(1, Iterables.size(intersectingElements));
 247         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 248     }
 249
 250     /**
 251      * Testing method {@link ISegmentStore#getIntersectingElements(long time)}
 252      */
 253     @Test
 254     public void testGetIntersectingElementsTime() {
 255
 256         Iterable<ISegment> intersectingElements;
 257
 258         /*
 259          * Time between segment start time and end time
 260          */
 261         intersectingElements = fSegmentStore.getIntersectingElements(3);
 262         assertEquals(1, Iterables.size(intersectingElements));
 263         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 264
 265         /*
 266          * Time on segment start time
 267          */
 268         intersectingElements = fSegmentStore.getIntersectingElements(2);
 269         assertEquals(1, Iterables.size(intersectingElements));
 270         assertEquals(SEGMENT_2_6, Iterables.getOnlyElement(intersectingElements));
 271
 272         /*
 273          * Time on segment end time
 274          */
 275         intersectingElements = fSegmentStore.getIntersectingElements(14);
 276         assertEquals(1, Iterables.size(intersectingElements));
 277         assertEquals(SEGMENT_10_14, Iterables.getOnlyElement(intersectingElements));
 278
 279         /*
 280          * Time overlapping many segments
 281          */
 282         intersectingElements = fSegmentStore.getIntersectingElements(6);
 283         assertEquals(4, Iterables.size(intersectingElements));
 284
 285         /*
 286          * Time between segments
 287          */
 288         intersectingElements = fSegmentStore.getIntersectingElements(9);
 289         assertEquals(0, Iterables.size(intersectingElements));
 290
 291         /*
 292          * Time before all segment start time
 293          */
 294         intersectingElements = fSegmentStore.getIntersectingElements(1);
 295         assertEquals(0, Iterables.size(intersectingElements));
 296
 297         /*
 298          * Time after all segment end time
 299          */
 300         intersectingElements = fSegmentStore.getIntersectingElements(15);
 301         assertEquals(0, Iterables.size(intersectingElements));
 302     }
 303
 304     /**
 305      * Testing method {@link ISegmentStore#dispose()}
 306      */
 307     @Test
 308     public void testDispose() {
 309         ISegmentStore<@NonNull ISegment> store = getSegmentStore();
 310         store.add(SEGMENT_2_6);
 311         store.dispose();
 312         assertEquals(0, store.size());
 313     }
 314
 315     /**
 316      * Test iterating over a store being built.
 317      *
 318      * bug 500607
 319      */
 320     @Test
 321     public void testIterator() {
 322         Collection<@NonNull ISegment> beforeExpected = ImmutableList.of(SEGMENT_2_6);
 323         Collection<@NonNull ISegment> afterExpected = ImmutableList.of(SEGMENT_2_6, SEGMENT_4_8);
 324         Collection<@NonNull ISegment> lastExpected = ImmutableList.of(SEGMENT_2_6, SEGMENT_4_8, SEGMENT_6_8);
 325         Collection<@NonNull ISegment> fixture = new ArrayList<>();
 326         ISegmentStore<@NonNull ISegment> store = getSegmentStore();
 327
 328         // Add one segment to the segment store and iterate
 329         store.add(SEGMENT_2_6);
 330         for (ISegment item : store) {
 331             fixture.add(item);
 332         }
 333         assertEquals(beforeExpected, fixture);
 334
 335         // Add a second segment to the store and iterate
 336         fixture.clear();
 337         store.add(SEGMENT_4_8);
 338         for (ISegment item : store) {
 339             fixture.add(item);
 340         }
 341         assertEquals(afterExpected, fixture);
 342
 343         fixture.clear();
 344         // Take an iterator
 345         Iterator<@NonNull ISegment> iter = store.iterator();
 346
 347         // Add a third segment to the store and iterate
 348         store.add(SEGMENT_6_8);
 349         Iterator<@NonNull ISegment> iter2 = store.iterator();
 350         fixture.clear();
 351
 352         // Make sure the first iterator take has only 2 elements and the second
 353         // has 3 elements
 354         while (iter.hasNext()) {
 355             fixture.add(iter.next());
 356         }
 357         assertEquals(afterExpected, fixture);
 358         fixture.clear();
 359         while (iter2.hasNext()) {
 360             fixture.add(iter2.next());
 361         }
 362         assertEquals(lastExpected, fixture);
 363     }
 364
 365 }