| /******************************************************************************* |
| * Copyright (c) 2016 École Polytechnique de Montréal |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License 2.0 which |
| * accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| *******************************************************************************/ |
| |
| package org.eclipse.tracecompass.statesystem.core.tests; |
| |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertFalse; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.tracecompass.common.core.NonNullUtils; |
| import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem; |
| import org.eclipse.tracecompass.statesystem.core.ITmfStateSystemBuilder; |
| import org.eclipse.tracecompass.statesystem.core.StateSystemFactory; |
| import org.eclipse.tracecompass.statesystem.core.StateSystemUtils; |
| import org.eclipse.tracecompass.statesystem.core.backend.IStateHistoryBackend; |
| import org.eclipse.tracecompass.statesystem.core.backend.StateHistoryBackendFactory; |
| import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException; |
| import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException; |
| import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException; |
| import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval; |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Multimap; |
| import com.google.common.collect.Ordering; |
| import com.google.common.collect.TreeMultimap; |
| |
| /** |
| * Test the 2D State System queries |
| * |
| * @author Loïc Prieur-Drevon |
| */ |
| public class StateSystem2DTest { |
| |
| private static final long START_TIME = 50L; |
| private static final @NonNull String STRING_ATTRIBUTE = "String"; |
| private static final @NonNull String INTEGER_ATTRIBUTE = "Integer"; |
| |
| private ITmfStateSystemBuilder fStateSystem; |
| |
| /** |
| * Build a small state history tree |
| * |
| * @throws IOException |
| * If the state system file could not be created |
| */ |
| @Before |
| public void setupStateSystem() throws IOException { |
| IStateHistoryBackend backend = StateHistoryBackendFactory.createHistoryTreeBackendNewFile("test", |
| NonNullUtils.checkNotNull(File.createTempFile("2Dtest", "ht")), 0, START_TIME, 0); |
| fStateSystem = StateSystemFactory.newStateSystem(NonNullUtils.checkNotNull(backend)); |
| int stringQuark = fStateSystem.getQuarkAbsoluteAndAdd(STRING_ATTRIBUTE); |
| int integerQuark = fStateSystem.getQuarkAbsoluteAndAdd(INTEGER_ATTRIBUTE); |
| |
| fStateSystem.modifyAttribute(60L, "String1", stringQuark); |
| fStateSystem.modifyAttribute(70L, 0, integerQuark); |
| fStateSystem.modifyAttribute(80L, 1, integerQuark); |
| fStateSystem.modifyAttribute(90L, "String2", stringQuark); |
| fStateSystem.modifyAttribute(100L, 2, integerQuark); |
| fStateSystem.modifyAttribute(110L, 3, integerQuark); |
| fStateSystem.modifyAttribute(130L, "String3", stringQuark); |
| fStateSystem.modifyAttribute(140L, "String4", stringQuark); |
| fStateSystem.modifyAttribute(160L, 4, integerQuark); |
| |
| fStateSystem.closeHistory(200L); |
| } |
| |
| /** |
| * Clean-up |
| */ |
| @After |
| public void tearDown() { |
| fStateSystem.dispose(); |
| fStateSystem.removeFiles(); |
| } |
| |
| private static void testContinuous(Iterable<ITmfStateInterval> iterable, Collection<Integer> quarks, long start, long end, int totalCount) { |
| Multimap<Integer, ITmfStateInterval> treeMap = TreeMultimap.create(Comparator.naturalOrder(), |
| Comparator.comparing(ITmfStateInterval::getStartTime)); |
| |
| iterable.forEach(interval -> assertTrue("Interval: " + interval + " was already returned: " + treeMap, |
| treeMap.put(interval.getAttribute(), interval))); |
| assertEquals("Wrong number of intervals returned", totalCount, treeMap.size()); |
| assertEquals("There should only be as many Sets of intervals as quarks", |
| quarks.size(), treeMap.keySet().size()); |
| |
| for (Integer quark : quarks) { |
| Collection<ITmfStateInterval> orderedSet = treeMap.get(quark); |
| assertFalse("There should be intervals for quark: " + quark, orderedSet.isEmpty()); |
| ITmfStateInterval previous = null; |
| for (ITmfStateInterval interval : orderedSet) { |
| if (previous == null) { |
| assertTrue("The first interval: " + interval + "should intersect start: " + start, interval.intersects(start)); |
| } else { |
| assertEquals("Current interval: " + interval + " should have been contiguous to the previous one " + previous, |
| previous.getEndTime() + 1, interval.getStartTime()); |
| } |
| previous = interval; |
| } |
| assertNotNull("There should have been at least one interval for quark " + quark, previous); |
| assertTrue("last interval: " + previous + " should intersect end " + end, previous.intersects(end)); |
| } |
| } |
| |
| /** |
| * Test the continuous 2D query method. |
| * |
| * @throws AttributeNotFoundException |
| * if the requested attribute simply did not exist in the system. |
| * @throws StateSystemDisposedException |
| * If the query is sent after the state system has been disposed |
| * @throws TimeRangeException |
| * If the smallest time is before the state system start time. |
| * @throws IndexOutOfBoundsException |
| * If the smallest attribute is <0 or if the largest is >= to the |
| * number of attributes. |
| */ |
| @Test |
| public void testContinuous2DQuery() throws AttributeNotFoundException, IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| long end = ss.getCurrentEndTime(); |
| |
| /* Make sure all and only the String intervals are returned */ |
| int stringQuark = fStateSystem.getQuarkAbsolute(STRING_ATTRIBUTE); |
| Iterable<ITmfStateInterval> iterable = ss.query2D(Collections.singleton(stringQuark), START_TIME, end); |
| testContinuous(iterable, Collections.singleton(stringQuark), START_TIME, end, 5); |
| |
| /* Make sure all and only the Integer intervals are returned */ |
| int integerQuark = fStateSystem.getQuarkAbsolute(INTEGER_ATTRIBUTE); |
| iterable = ss.query2D(Collections.singleton(integerQuark), START_TIME, end); |
| testContinuous(iterable, Collections.singleton(integerQuark), START_TIME, end, 6); |
| |
| /* Make sure all intervals are returned */ |
| Collection<Integer> quarks = ImmutableList.of(stringQuark, integerQuark); |
| iterable = ss.query2D(quarks, START_TIME, end); |
| testContinuous(iterable, quarks, START_TIME, end, 11); |
| } |
| |
| private static void testDiscrete(Iterable<ITmfStateInterval> iterable, Collection<Integer> quarks, Collection<Long> times, int totalCount) { |
| Set<ITmfStateInterval> set = new HashSet<>(); |
| int countTimeStamps = 0; |
| |
| for (ITmfStateInterval interval : iterable) { |
| assertTrue(quarks.contains(interval.getAttribute())); |
| assertTrue("interval: " + interval + " was returned twice", set.add(interval)); |
| |
| int timeStamps = (int) times.stream().filter(interval::intersects).count(); |
| assertTrue("interval: " + interval + " does not intersect any time stamp: " + times, timeStamps > 0); |
| countTimeStamps += timeStamps; |
| } |
| |
| assertEquals("incorrect number of intervals returned", totalCount, set.size()); |
| assertEquals("All the queried time stamps were not covered", times.size() * quarks.size(), countTimeStamps); |
| } |
| |
| /** |
| * Test the discrete 2D query method. |
| * |
| * @throws AttributeNotFoundException |
| * if the requested attribute simply did not exist in the system. |
| * @throws StateSystemDisposedException |
| * If the query is sent after the state system has been disposed |
| * @throws TimeRangeException |
| * If the smallest time is before the state system start time. |
| * @throws IndexOutOfBoundsException |
| * If the smallest attribute is <0 or if the largest is >= to the |
| * number of attributes. |
| */ |
| @Test |
| public void testDiscrete2DQuery() throws AttributeNotFoundException, |
| IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| long end = ss.getCurrentEndTime(); |
| Collection<Long> times = StateSystemUtils.getTimes(START_TIME, end, 30L); |
| assertEquals(6, times.size()); |
| assertTrue(Ordering.natural().isStrictlyOrdered(times)); |
| |
| /* Make sure all and only the String intervals are returned */ |
| int stringQuark = fStateSystem.getQuarkAbsolute(STRING_ATTRIBUTE); |
| Iterable<ITmfStateInterval> iterable = ss.query2D(Collections.singleton(stringQuark), times); |
| testDiscrete(iterable, Collections.singleton(stringQuark), times, 4); |
| |
| /* Make sure all and only the Integer intervals are returned */ |
| int integerQuark = fStateSystem.getQuarkAbsolute(INTEGER_ATTRIBUTE); |
| iterable = ss.query2D(Collections.singleton(integerQuark), times); |
| testDiscrete(iterable, Collections.singleton(integerQuark), times, 4); |
| |
| /* Make sure all intervals are returned */ |
| Collection<Integer> quarks = ImmutableList.of(stringQuark, integerQuark); |
| iterable = ss.query2D(quarks, times); |
| testDiscrete(iterable, quarks, times, 8); |
| } |
| |
| /** |
| * Test index out of bound queries |
| * |
| * @throws StateSystemDisposedException |
| * ss was closed |
| * @throws TimeRangeException |
| * time was out of range |
| * @throws IndexOutOfBoundsException |
| * queried an attribute that was out of bounds |
| */ |
| @Test(expected = IndexOutOfBoundsException.class) |
| public void testIOOB2DQuery() throws IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| Collection<Long> times = Collections.singleton(77L); |
| |
| int stringQuark = Integer.MAX_VALUE; |
| ss.query2D(Collections.singleton(stringQuark), times); |
| } |
| |
| /** |
| * Test a too low time range exception on continuous queries |
| * |
| * @throws StateSystemDisposedException |
| * ss was closed |
| * @throws TimeRangeException |
| * time was out of range |
| * @throws IndexOutOfBoundsException |
| * queried an attribute that was out of bounds |
| */ |
| @Test(expected = TimeRangeException.class) |
| public void testTimeRangeException2DContinous() throws IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| |
| ss.query2D(Collections.singleton(0), 0L, 77L); |
| } |
| |
| /** |
| * Test a too low time range exception on discrete queries |
| * |
| * @throws StateSystemDisposedException |
| * ss was closed |
| * @throws TimeRangeException |
| * time was out of range |
| * @throws IndexOutOfBoundsException |
| * queried an attribute that was out of bounds |
| */ |
| @Test(expected = TimeRangeException.class) |
| public void testTimeRangeException2DDiscrete() throws IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| |
| ss.query2D(Collections.singleton(0), Collections.singleton(Long.MIN_VALUE)); |
| } |
| |
| /** |
| * Test Empty queries |
| * |
| * @throws StateSystemDisposedException |
| * ss was closed |
| * @throws TimeRangeException |
| * time was out of range |
| * @throws IndexOutOfBoundsException |
| * queried an attribute that was out of bounds |
| */ |
| @Test |
| public void testEmpty2DQuery() throws IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| |
| /* Test on a discrete query */ |
| Iterable<ITmfStateInterval> iterable = ss.query2D(Collections.emptyList(), Collections.singleton(77L)); |
| assertNotNull(iterable); |
| assertTrue(Iterables.isEmpty(iterable)); |
| |
| /* Test on an empty time sample */ |
| iterable = ss.query2D(Collections.singleton(0), Collections.emptyList()); |
| assertNotNull(iterable); |
| assertTrue(Iterables.isEmpty(iterable)); |
| |
| /* Test on a continuous query */ |
| iterable = ss.query2D(Collections.emptyList(), 77L, 78L); |
| assertNotNull(iterable); |
| assertTrue(Iterables.isEmpty(iterable)); |
| } |
| |
| /** |
| * Test the continuous 2D query method when start time > end time. Since |
| * this state system only has one node, it does not compare behavior between |
| * reverse and not reverse queries. |
| * |
| * @throws AttributeNotFoundException |
| * if the requested attribute simply did not exist in the |
| * system. |
| * @throws StateSystemDisposedException |
| * If the query is sent after the state system has been disposed |
| * @throws TimeRangeException |
| * If the smallest time is before the state system start time. |
| * @throws IndexOutOfBoundsException |
| * If the smallest attribute is <0 or if the largest is >= to |
| * the number of attributes. |
| */ |
| @Test |
| public void testReverse2DQuery() throws AttributeNotFoundException, IndexOutOfBoundsException, TimeRangeException, StateSystemDisposedException { |
| ITmfStateSystem ss = fStateSystem; |
| assertNotNull(ss); |
| long end = ss.getCurrentEndTime(); |
| |
| /* Make sure all and only the String intervals are returned */ |
| int stringQuark = fStateSystem.getQuarkAbsolute(STRING_ATTRIBUTE); |
| Iterable<ITmfStateInterval> iterable = ss.query2D(Collections.singleton(stringQuark), end, START_TIME); |
| testContinuous(iterable, Collections.singleton(stringQuark), START_TIME, end, 5); |
| |
| /* Make sure all and only the Integer intervals are returned */ |
| int integerQuark = fStateSystem.getQuarkAbsolute(INTEGER_ATTRIBUTE); |
| iterable = ss.query2D(Collections.singleton(integerQuark), end, START_TIME); |
| testContinuous(iterable, Collections.singleton(integerQuark), START_TIME, end, 6); |
| |
| /* Make sure all intervals are returned */ |
| Collection<Integer> quarks = ImmutableList.of(stringQuark, integerQuark); |
| iterable = ss.query2D(quarks, end, START_TIME); |
| testContinuous(iterable, quarks, START_TIME, end, 11); |
| } |
| |
| } |
