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