tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/synchronization/TsTransformFactoryTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2014 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are made
   5  * 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  * Contributors:
  10  *   Matthew Khouzam - Initial implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.core.tests.synchronization;
  14
  15 import static org.junit.Assert.assertEquals;
  16
  17 import java.math.BigDecimal;
  18
  19 import org.eclipse.jdt.annotation.NonNullByDefault;
  20 import org.eclipse.tracecompass.common.core.NonNullUtils;
  21 import org.eclipse.tracecompass.internal.tmf.core.synchronization.TmfConstantTransform;
  22 import org.eclipse.tracecompass.tmf.core.synchronization.ITmfTimestampTransform;
  23 import org.eclipse.tracecompass.tmf.core.synchronization.TimestampTransformFactory;
  24 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  25 import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
  26 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  27 import org.junit.Test;
  28
  29 /**
  30  * Timestamp transform tests
  31  *
  32  * @author Matthew Khouzam
  33  *
  34  */
  35 @NonNullByDefault
  36 public class TsTransformFactoryTest {
  37     private final ITmfTimestamp t0 = new TmfTimestamp(0);
  38     private final ITmfTimestamp t100 = new TmfTimestamp(100);
  39     private final ITmfTimestamp t1e2 = new TmfTimestamp(1, 2);
  40     private final ITmfTimestamp t1e3 = new TmfTimestamp(1, 3);
  41     private final ITmfTimestamp tn0 = new TmfNanoTimestamp(0);
  42     private final ITmfTimestamp tn100 = new TmfNanoTimestamp(100);
  43     private final ITmfTimestamp tn1 = new TmfNanoTimestamp(1);
  44     private final ITmfTimestampTransform identity1 = TimestampTransformFactory.createLinear(1.0, new TmfNanoTimestamp(0));
  45     private final ITmfTimestampTransform offset1 = TimestampTransformFactory.createWithOffset(100);
  46     private final ITmfTimestampTransform offset2 = TimestampTransformFactory.createLinear(NonNullUtils.checkNotNull(BigDecimal.ONE), NonNullUtils.checkNotNull(new BigDecimal(100)));
  47     private final ITmfTimestampTransform offset3 = TimestampTransformFactory.createLinear(1.0, 100);
  48     private final ITmfTimestampTransform offset4 = TimestampTransformFactory.createLinear(1.0, new TmfNanoTimestamp(100));
  49
  50     /**
  51      * Test with identity
  52      */
  53     @Test
  54     public void transformIdentity() {
  55         final ITmfTimestampTransform identity = TimestampTransformFactory.createWithOffset(0);
  56         final ITmfTimestampTransform innefficientIdentity = new TmfConstantTransform();
  57         final ITmfTimestampTransform compositeInnefficientIdentity = identity.composeWith(innefficientIdentity);
  58         final ITmfTimestampTransform compositeInnefficientIdentity2 = innefficientIdentity.composeWith(innefficientIdentity);
  59         final ITmfTimestampTransform compositeInnefficientIdentity3 = innefficientIdentity.composeWith(identity);
  60         assertEquals(t0, identity.transform(t0));
  61         assertEquals(tn0, identity.transform(tn0));
  62         assertEquals(t100, identity.transform(t100));
  63         assertEquals(t1e2, identity.transform(t100));
  64         assertEquals(t1e2, identity.transform(t1e2));
  65         assertEquals(t1e3, identity.transform(t1e3));
  66         assertEquals(tn100, identity.transform(tn100));
  67         assertEquals(t0, innefficientIdentity.transform(t0)); // bad practice
  68         assertEquals(t0, compositeInnefficientIdentity.transform(t0)); // bad
  69                                                                        // practice
  70         assertEquals(t0, compositeInnefficientIdentity2.transform(t0)); // bad
  71                                                                         // practice
  72         assertEquals(t0, compositeInnefficientIdentity3.transform(t0)); // bad
  73                                                                         // practice
  74     }
  75
  76     /**
  77      * Test with an offset of 100
  78      */
  79     @Test
  80     public void transformOffset() {
  81         final ITmfTimestampTransform offset = offset1;
  82         final ITmfTimestampTransform compositeTransform = offset.composeWith(TimestampTransformFactory.createWithOffset(new TmfNanoTimestamp(-100)));
  83         assertEquals(tn100, offset.transform(t0));
  84         assertEquals(tn100, offset.transform(tn0));
  85         assertEquals(tn0, compositeTransform.transform(tn0));
  86         assertEquals(t0, compositeTransform.transform(t0));
  87         assertEquals(200, offset1.transform(100));
  88         assertEquals(200, offset2.transform(100));
  89         assertEquals(200, offset3.transform(100));
  90         assertEquals(200, offset4.transform(100));
  91     }
  92
  93     /**
  94      * Test with a slope
  95      */
  96     @Test
  97     public void transformSlope() {
  98         final ITmfTimestampTransform slope = TimestampTransformFactory.createLinear(10, 0);
  99         final ITmfTimestampTransform slope1 = TimestampTransformFactory.createLinear(10.0, new TmfNanoTimestamp(0));
 100         assertEquals(t1e3, slope.transform(t1e2));
 101         assertEquals(tn100, slope.transform(new TmfNanoTimestamp(10)));
 102         assertEquals(tn100, slope.transform(slope.transform(tn1)));
 103         assertEquals(tn100, slope.composeWith(slope).transform(tn1));
 104         assertEquals(tn100, slope1.transform(new TmfNanoTimestamp(10)));
 105     }
 106
 107     /**
 108      * Test toStrings
 109      */
 110     @Test
 111     public void testToString() {
 112         final String expectedLinear = "TmfTimestampTransformLinearFast [ slope = 314.0, offset = 0.0 ]";
 113         final String expectedLinearBigDec = "TmfTimestampTransformLinearFast [ slope = 314, offset = 0 ]";
 114         final String expectedOffset = "TmfConstantTransform [ offset = 314 ]";
 115         final String expectedIdentity = "TmfTimestampTransform [ IDENTITY ]";
 116         final String expectedOffset100 = "TmfConstantTransform [ offset = 100 ]";
 117         assertEquals(expectedLinear, TimestampTransformFactory.createLinear(314, 0).toString());
 118         assertEquals(expectedLinearBigDec, TimestampTransformFactory.createLinear(NonNullUtils.checkNotNull(BigDecimal.valueOf(314)), NonNullUtils.checkNotNull(BigDecimal.ZERO)).toString());
 119         assertEquals(expectedOffset, TimestampTransformFactory.createLinear(1, 314).toString());
 120         assertEquals(expectedOffset, TimestampTransformFactory.createWithOffset(314).toString());
 121         assertEquals(expectedOffset, TimestampTransformFactory.createWithOffset(14).composeWith(TimestampTransformFactory.createWithOffset(300)).toString());
 122         assertEquals(expectedIdentity, TimestampTransformFactory.createWithOffset(314).composeWith(TimestampTransformFactory.createWithOffset(-314)).toString());
 123         assertEquals(expectedIdentity, TimestampTransformFactory.createWithOffset(0).toString());
 124         assertEquals(expectedIdentity, identity1.toString());
 125         assertEquals(expectedOffset100, offset1.toString());
 126         assertEquals(expectedOffset100, offset2.toString());
 127         assertEquals(expectedOffset100, offset3.toString());
 128         assertEquals(expectedOffset100, offset4.toString());
 129     }
 130 }