org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfCheckpointTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010, 2012 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  * Contributors:
  10  *   Francois Chouinard - Initial API and implementation
  11  *   Francois Chouinard - Adapted for TMF Trace Model 1.0
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.tests.trace;
  15
  16 import junit.framework.TestCase;
  17
  18 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  19 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  20 import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpoint;
  21 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
  22 import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
  23
  24 /**
  25  * Test suite for the TmfCheckpoint class.
  26  */
  27 @SuppressWarnings({"nls","javadoc"})
  28 public class TmfCheckpointTest extends TestCase {
  29
  30     // ------------------------------------------------------------------------
  31     // Variables
  32     // ------------------------------------------------------------------------
  33
  34     ITmfTimestamp fTimestamp1 = new TmfTimestamp();
  35     ITmfTimestamp fTimestamp2 = TmfTimestamp.BIG_BANG;
  36     ITmfTimestamp fTimestamp3 = TmfTimestamp.BIG_CRUNCH;
  37
  38     Long aLong1 = 12345L;
  39     Long aLong2 = 23456L;
  40     Long aLong3 = 34567L;
  41     TmfLocation<Long> fLocation1 = new TmfLocation<Long>(aLong1);
  42     TmfLocation<Long> fLocation2 = new TmfLocation<Long>(aLong2);
  43     TmfLocation<Long> fLocation3 = new TmfLocation<Long>(aLong3);
  44
  45     TmfCheckpoint fCheckpoint1 = new TmfCheckpoint(fTimestamp1, new TmfContext(fLocation1));
  46     TmfCheckpoint fCheckpoint2 = new TmfCheckpoint(fTimestamp2, new TmfContext(fLocation2));
  47     TmfCheckpoint fCheckpoint3 = new TmfCheckpoint(fTimestamp3, new TmfContext(fLocation3));
  48
  49     // ------------------------------------------------------------------------
  50     // Housekeeping
  51     // ------------------------------------------------------------------------
  52
  53     /**
  54      * @param name the test name
  55      */
  56     public TmfCheckpointTest(final String name) {
  57         super(name);
  58     }
  59
  60     @Override
  61     protected void setUp() throws Exception {
  62         super.setUp();
  63     }
  64
  65     @Override
  66     protected void tearDown() throws Exception {
  67         super.tearDown();
  68     }
  69
  70     // ------------------------------------------------------------------------
  71     // Constructors
  72     // ------------------------------------------------------------------------
  73
  74     public void testTmfCheckpoint() {
  75         assertEquals("TmfCheckpoint", fTimestamp1, fCheckpoint1.getTimestamp());
  76         assertEquals("TmfCheckpoint", fLocation1,  fCheckpoint1.getLocation());
  77     }
  78
  79     public void testTmfLocationCopy() {
  80         final TmfCheckpoint checkpoint = new TmfCheckpoint(fCheckpoint1);
  81
  82         assertEquals("TmfCheckpoint", fTimestamp1, checkpoint.getTimestamp());
  83         assertEquals("TmfCheckpoint", fLocation1,  checkpoint.getLocation());
  84     }
  85
  86     public void testTmfLocationCopy2() {
  87         try {
  88             new TmfCheckpoint(null);
  89             fail("null copy");
  90         }
  91         catch (final IllegalArgumentException e) {
  92             // Success
  93         }
  94         catch (final Exception e) {
  95             fail("wrong exception");
  96         }
  97     }
  98
  99     // ------------------------------------------------------------------------
 100     // clone
 101     // ------------------------------------------------------------------------
 102
 103     public void testClone() {
 104         try {
 105             TmfCheckpoint checkpoint1 = fCheckpoint1.clone();
 106             TmfCheckpoint checkpoint2 = fCheckpoint1.clone();
 107             TmfCheckpoint checkpoint3 = fCheckpoint1.clone();
 108
 109             assertEquals("clone", checkpoint1, fCheckpoint1);
 110             assertEquals("clone", checkpoint2, fCheckpoint1);
 111             assertEquals("clone", checkpoint3, fCheckpoint1);
 112
 113             checkpoint1 = new TmfCheckpoint(fTimestamp1, null);
 114             checkpoint2 = checkpoint1.clone();
 115             assertEquals("clone", checkpoint1, checkpoint2);
 116             assertNull(checkpoint1.getContext());
 117             assertNull(checkpoint2.getContext());
 118
 119             checkpoint1 = new TmfCheckpoint(null, new TmfContext(fLocation1));
 120             checkpoint3 = checkpoint1.clone();
 121             assertEquals("clone", checkpoint1, checkpoint3);
 122             assertNull(checkpoint1.getTimestamp());
 123             assertNull(checkpoint3.getTimestamp());
 124
 125         } catch (final InternalError e) {
 126             fail("clone()");
 127         }
 128     }
 129
 130     // ------------------------------------------------------------------------
 131     // compareTo
 132     // ------------------------------------------------------------------------
 133
 134     public void testCompareTo() {
 135         assertEquals("compareTo",  0, fCheckpoint1.compareTo(fCheckpoint1));
 136         assertEquals("compareTo",  1, fCheckpoint1.compareTo(fCheckpoint2));
 137         assertEquals("compareTo", -1, fCheckpoint1.compareTo(fCheckpoint3));
 138
 139         assertEquals("compareTo", -1, fCheckpoint2.compareTo(fCheckpoint1));
 140         assertEquals("compareTo",  0, fCheckpoint2.compareTo(fCheckpoint2));
 141         assertEquals("compareTo", -1, fCheckpoint2.compareTo(fCheckpoint3));
 142
 143         assertEquals("compareTo",  1, fCheckpoint3.compareTo(fCheckpoint1));
 144         assertEquals("compareTo",  1, fCheckpoint3.compareTo(fCheckpoint2));
 145         assertEquals("compareTo",  0, fCheckpoint3.compareTo(fCheckpoint3));
 146     }
 147
 148     public void testCompareToNull() {
 149         final TmfCheckpoint checkpoint1 = new TmfCheckpoint(null, new TmfContext(fLocation1));
 150         final TmfCheckpoint checkpoint2 = new TmfCheckpoint(null, new TmfContext(fLocation2));
 151         final TmfCheckpoint checkpoint3 = new TmfCheckpoint(null, new TmfContext(fLocation3));
 152         final TmfCheckpoint checkpoint4 = new TmfCheckpoint(null, new TmfContext(fLocation1));
 153
 154         // Test the various 'null' vs. '!null' combinations
 155         assertEquals("compareTo",  0, checkpoint1.compareTo(fCheckpoint1));
 156         assertEquals("compareTo",  0, fCheckpoint1.compareTo(checkpoint1));
 157         assertEquals("compareTo", -1, checkpoint1.compareTo(fCheckpoint2));
 158         assertEquals("compareTo",  1, fCheckpoint2.compareTo(checkpoint1));
 159         assertEquals("compareTo", -1, checkpoint1.compareTo(fCheckpoint3));
 160         assertEquals("compareTo",  1, fCheckpoint3.compareTo(checkpoint1));
 161
 162         // Test the 'null' vs. 'null' combinations
 163         assertEquals("compareTo",  0, checkpoint1.compareTo(checkpoint4));
 164         assertEquals("compareTo",  0, checkpoint4.compareTo(checkpoint1));
 165         assertEquals("compareTo", -1, checkpoint1.compareTo(checkpoint2));
 166         assertEquals("compareTo",  1, checkpoint2.compareTo(checkpoint1));
 167         assertEquals("compareTo", -1, checkpoint1.compareTo(checkpoint3));
 168         assertEquals("compareTo",  1, checkpoint3.compareTo(checkpoint1));
 169     }
 170
 171     // ------------------------------------------------------------------------
 172     // hashCode
 173     // ------------------------------------------------------------------------
 174
 175     public void testHashCode() {
 176         final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fCheckpoint1);
 177         final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fCheckpoint2);
 178
 179         assertTrue("hashCode", fCheckpoint1.hashCode() == checkpoint1.hashCode());
 180         assertTrue("hashCode", fCheckpoint2.hashCode() == checkpoint2.hashCode());
 181
 182         assertTrue("hashCode", fCheckpoint1.hashCode() != checkpoint2.hashCode());
 183         assertTrue("hashCode", fCheckpoint2.hashCode() != checkpoint1.hashCode());
 184     }
 185
 186     public void testHashCodeNull() {
 187         final TmfCheckpoint checkpoint1 = new TmfCheckpoint(null, new TmfContext(fLocation1));
 188         final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fTimestamp1, null);
 189         final TmfCheckpoint checkpoint3 = new TmfCheckpoint(checkpoint1);
 190         final TmfCheckpoint checkpoint4 = new TmfCheckpoint(checkpoint2);
 191
 192         assertTrue("hashCode", fCheckpoint1.hashCode() != checkpoint1.hashCode());
 193         assertTrue("hashCode", fCheckpoint1.hashCode() != checkpoint2.hashCode());
 194
 195         assertTrue("hashCode", checkpoint1.hashCode() == checkpoint3.hashCode());
 196         assertTrue("hashCode", checkpoint2.hashCode() == checkpoint4.hashCode());
 197     }
 198
 199     // ------------------------------------------------------------------------
 200     // equals
 201     // ------------------------------------------------------------------------
 202
 203     public void testEqualsReflexivity() {
 204         assertTrue("equals", fCheckpoint1.equals(fCheckpoint1));
 205         assertTrue("equals", fCheckpoint2.equals(fCheckpoint2));
 206
 207         assertTrue("equals", !fCheckpoint1.equals(fCheckpoint2));
 208         assertTrue("equals", !fCheckpoint2.equals(fCheckpoint1));
 209     }
 210
 211     public void testEqualsSymmetry() {
 212         final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fCheckpoint1);
 213         final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fCheckpoint2);
 214
 215         assertTrue("equals", checkpoint1.equals(fCheckpoint1));
 216         assertTrue("equals", fCheckpoint1.equals(checkpoint1));
 217
 218         assertTrue("equals", checkpoint2.equals(fCheckpoint2));
 219         assertTrue("equals", fCheckpoint2.equals(checkpoint2));
 220     }
 221
 222     public void testEqualsTransivity() {
 223         final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fCheckpoint1);
 224         final TmfCheckpoint checkpoint2 = new TmfCheckpoint(checkpoint1);
 225         final TmfCheckpoint checkpoint3 = new TmfCheckpoint(checkpoint2);
 226
 227         assertTrue("equals", checkpoint1.equals(checkpoint2));
 228         assertTrue("equals", checkpoint2.equals(checkpoint3));
 229         assertTrue("equals", checkpoint1.equals(checkpoint3));
 230     }
 231
 232     public void testNotEqual() {
 233         // Various checkpoints
 234         final TmfCheckpoint checkpoint1 = new TmfCheckpoint(fTimestamp1, new TmfContext(fLocation1));
 235         final TmfCheckpoint checkpoint2 = new TmfCheckpoint(fTimestamp2, new TmfContext(fLocation1));
 236         final TmfCheckpoint checkpoint3 = new TmfCheckpoint(fTimestamp1, new TmfContext(fLocation2));
 237         final TmfCheckpoint checkpoint4 = new TmfCheckpoint(fTimestamp1, null);
 238         final TmfCheckpoint checkpoint5 = new TmfCheckpoint(null, new TmfContext(fLocation1));
 239
 240         // Null check
 241         assertFalse("equals", checkpoint1.equals(null));
 242
 243         // Different types
 244         assertFalse("equals", checkpoint1.equals(new TmfTimestamp()));
 245
 246         // Null locations/location
 247         assertFalse("equals", checkpoint1.equals(checkpoint4));
 248         assertFalse("equals", checkpoint1.equals(checkpoint5));
 249         assertFalse("equals", checkpoint4.equals(checkpoint1));
 250         assertFalse("equals", checkpoint5.equals(checkpoint1));
 251
 252         // Different locations/location
 253         assertFalse("equals", checkpoint1.equals(checkpoint2));
 254         assertFalse("equals", checkpoint1.equals(checkpoint3));
 255     }
 256
 257     // ------------------------------------------------------------------------
 258     // toString
 259     // ------------------------------------------------------------------------
 260
 261     public void testToString() {
 262         final String expected1 = "TmfCheckpoint [fContext=" + fCheckpoint1.getContext() +
 263                 ", fTimestamp=" + fCheckpoint1.getTimestamp() + "]";
 264         final String expected2 = "TmfCheckpoint [fContext=" + fCheckpoint2.getContext() +
 265                 ", fTimestamp=" + fCheckpoint2.getTimestamp() + "]";
 266         final String expected3 = "TmfCheckpoint [fContext=" + fCheckpoint3.getContext() +
 267                 ", fTimestamp=" + fCheckpoint3.getTimestamp() + "]";
 268
 269         assertEquals("toString", expected1, fCheckpoint1.toString());
 270         assertEquals("toString", expected2, fCheckpoint2.toString());
 271         assertEquals("toString", expected3, fCheckpoint3.toString());
 272     }
 273
 274 }