org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/event/TmfTimeRangeTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 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  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.core.tests.event;
  14
  15 import junit.framework.TestCase;
  16
  17 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  18 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  19 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  20
  21 /**
  22  * <b><u>TmfTimeRangeTest</u></b>
  23  * <p>
  24  * Test suite for the TmfTimeRange class.
  25  */
  26 @SuppressWarnings("nls")
  27 public class TmfTimeRangeTest extends TestCase {
  28
  29         // ------------------------------------------------------------------------
  30         // Housekeeping
  31         // ------------------------------------------------------------------------
  32
  33         public TmfTimeRangeTest(String name) {
  34                 super(name);
  35         }
  36
  37         @Override
  38         protected void setUp() throws Exception {
  39                 super.setUp();
  40         }
  41
  42         @Override
  43         protected void tearDown() throws Exception {
  44                 super.tearDown();
  45         }
  46
  47         // ------------------------------------------------------------------------
  48         // Constructors
  49         // ------------------------------------------------------------------------
  50
  51     public void testConstructor() throws Exception {
  52         ITmfTimestamp ts1 = new TmfTimestamp(12345);
  53         ITmfTimestamp ts2 = new TmfTimestamp(12350);
  54         TmfTimeRange range = new TmfTimeRange(ts1, ts2);
  55
  56         assertEquals("startTime", ts1, range.getStartTime());
  57         assertEquals("endTime", ts2, range.getEndTime());
  58     }
  59
  60     public void testBadConstructor() throws Exception {
  61         try {
  62             new TmfTimeRange(TmfTimestamp.BigBang, null);
  63             fail("null copy");
  64         } catch (IllegalArgumentException e) {
  65             // Success
  66         }
  67
  68         try {
  69             new TmfTimeRange(null, TmfTimestamp.BigCrunch);
  70             fail("null copy");
  71         } catch (IllegalArgumentException e) {
  72             // Success
  73         }
  74     }
  75
  76     public void testOpenRange1() throws Exception {
  77         ITmfTimestamp ts2 = new TmfTimestamp(12350);
  78         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, ts2);
  79
  80         assertEquals("startTime", TmfTimestamp.BigBang, range.getStartTime());
  81         assertEquals("endTime", ts2, range.getEndTime());
  82     }
  83
  84     public void testOpenRange2() throws Exception {
  85         ITmfTimestamp ts1 = new TmfTimestamp(12345);
  86         TmfTimeRange range = new TmfTimeRange(ts1, TmfTimestamp.BigCrunch);
  87
  88         assertEquals("startTime", ts1, range.getStartTime());
  89         assertEquals("endTime", TmfTimestamp.BigCrunch, range.getEndTime());
  90     }
  91
  92     public void testOpenRange3() throws Exception {
  93         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
  94
  95         assertEquals("startTime", TmfTimestamp.BigBang, range.getStartTime());
  96         assertEquals("endTime", TmfTimestamp.BigCrunch, range.getEndTime());
  97     }
  98
  99     public void testCopyConstructor() throws Exception {
 100         ITmfTimestamp ts1 = new TmfTimestamp(12345);
 101         ITmfTimestamp ts2 = new TmfTimestamp(12350);
 102         TmfTimeRange range0 = new TmfTimeRange(ts1, ts2);
 103         TmfTimeRange range1 = new TmfTimeRange(range0);
 104
 105         assertEquals("startTime", ts1, range1.getStartTime());
 106         assertEquals("endTime", ts2, range1.getEndTime());
 107
 108         TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 109         TmfTimeRange range3 = new TmfTimeRange(range2);
 110
 111         assertEquals("startTime", TmfTimestamp.BigBang, range3.getStartTime());
 112         assertEquals("endTime", TmfTimestamp.BigCrunch, range3.getEndTime());
 113     }
 114
 115     public void testCopyConstructor2() throws Exception {
 116         try {
 117             new TmfTimeRange(null);
 118             fail("null copy");
 119         } catch (IllegalArgumentException e) {
 120             // Success
 121         }
 122     }
 123
 124         // ------------------------------------------------------------------------
 125         // equals
 126         // ------------------------------------------------------------------------
 127
 128         public void testEqualsReflexivity() throws Exception {
 129                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 130                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 131                 TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
 132                 TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 133
 134                 assertTrue("equals", range1.equals(range1));
 135                 assertTrue("equals", range2.equals(range2));
 136
 137                 assertTrue("equals", !range1.equals(range2));
 138                 assertTrue("equals", !range2.equals(range1));
 139         }
 140
 141         public void testEqualsSymmetry() throws Exception {
 142                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 143                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 144                 TmfTimeRange range1a = new TmfTimeRange(ts1, ts2);
 145                 TmfTimeRange range1b = new TmfTimeRange(ts1, ts2);
 146
 147                 TmfTimeRange range2a = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 148                 TmfTimeRange range2b = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 149
 150                 assertTrue("equals", range1a.equals(range1b));
 151                 assertTrue("equals", range1b.equals(range1a));
 152
 153                 assertTrue("equals", range2a.equals(range2b));
 154                 assertTrue("equals", range2b.equals(range2a));
 155         }
 156
 157         public void testEqualsTransivity() throws Exception {
 158                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 159                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 160                 TmfTimeRange range1a = new TmfTimeRange(ts1, ts2);
 161                 TmfTimeRange range1b = new TmfTimeRange(ts1, ts2);
 162                 TmfTimeRange range1c = new TmfTimeRange(ts1, ts2);
 163
 164                 assertTrue("equals", range1a.equals(range1b));
 165                 assertTrue("equals", range1b.equals(range1c));
 166                 assertTrue("equals", range1a.equals(range1c));
 167         }
 168
 169         public void testEqualsNull() throws Exception {
 170                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 171                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 172                 TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
 173
 174                 assertTrue("equals", !range1.equals(null));
 175         }
 176
 177     public void testEqualsBadType() throws Exception {
 178         ITmfTimestamp ts1 = new TmfTimestamp(12345);
 179         ITmfTimestamp ts2 = new TmfTimestamp(12350);
 180         TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
 181
 182         assertTrue("equals", !range1.equals(ts1));
 183     }
 184
 185     public void testEqualStartTime() throws Exception {
 186         ITmfTimestamp ts1 = new TmfTimestamp(12345);
 187         ITmfTimestamp ts2 = new TmfTimestamp(12350);
 188         ITmfTimestamp ts3 = new TmfTimestamp(12355);
 189
 190         TmfTimeRange range1 = new TmfTimeRange(ts1, ts3);
 191         TmfTimeRange range2 = new TmfTimeRange(ts2, ts3);
 192         TmfTimeRange range3 = new TmfTimeRange(ts1, ts2);
 193
 194         assertTrue("equals", !range1.equals(range2));
 195         assertTrue("equals", !range1.equals(range3));
 196     }
 197
 198     public void testEqualsEndTime() throws Exception {
 199         ITmfTimestamp ts1 = new TmfTimestamp(12345);
 200         ITmfTimestamp ts2 = new TmfTimestamp(12350);
 201         ITmfTimestamp ts3 = new TmfTimestamp(12355);
 202
 203         TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
 204         TmfTimeRange range2 = new TmfTimeRange(ts1, ts3);
 205         TmfTimeRange range3 = new TmfTimeRange(ts2, ts3);
 206
 207         assertTrue("equals", !range1.equals(range2));
 208         assertTrue("equals", !range1.equals(range3));
 209     }
 210
 211         // ------------------------------------------------------------------------
 212         // hashCode
 213         // ------------------------------------------------------------------------
 214
 215         public void testHashCode() throws Exception {
 216                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 217                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 218                 TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
 219                 TmfTimeRange range1b = new TmfTimeRange(range1);
 220                 TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 221                 TmfTimeRange range2b = new TmfTimeRange(range2);
 222
 223                 assertTrue("hashCode", range1.hashCode() == range1b.hashCode());
 224                 assertTrue("hashCode", range2.hashCode() == range2b.hashCode());
 225
 226                 assertTrue("hashCode", range1.hashCode() != range2.hashCode());
 227         }
 228
 229         // ------------------------------------------------------------------------
 230         // clone
 231         // ------------------------------------------------------------------------
 232
 233         public void testClone() throws Exception {
 234                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 235                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 236
 237                 TmfTimeRange range = new TmfTimeRange(ts1, ts2);
 238         TmfTimeRange clone = range.clone();
 239
 240                 assertEquals("clone", range, clone);
 241         assertEquals("clone", ts1, clone.getStartTime());
 242         assertEquals("clone", ts2, clone.getEndTime());
 243         }
 244
 245     // ------------------------------------------------------------------------
 246     // toString
 247     // ------------------------------------------------------------------------
 248
 249     public void testToString() throws Exception {
 250         ITmfTimestamp ts1 = new TmfTimestamp(12345);
 251         ITmfTimestamp ts2 = new TmfTimestamp(12350);
 252         TmfTimeRange range = new TmfTimeRange(ts1, ts2);
 253
 254         String expected = "TmfTimeRange [fStartTime=" + ts1 + ", fEndTime=" + ts2 + "]";
 255         assertEquals("toString", expected, range.toString());
 256     }
 257
 258         // ------------------------------------------------------------------------
 259         // contains
 260         // ------------------------------------------------------------------------
 261
 262         public void testContainsTimestamp() throws Exception {
 263                 ITmfTimestamp ts1 = new TmfTimestamp(12345);
 264                 ITmfTimestamp ts2 = new TmfTimestamp(12350);
 265                 TmfTimeRange range = new TmfTimeRange(ts1, ts2);
 266
 267                 assertTrue("contains (lower bound)", range.contains(new TmfTimestamp(12345)));
 268                 assertTrue("contains (higher bound)", range.contains(new TmfTimestamp(12350)));
 269                 assertTrue("contains (within bounds)", range.contains(new TmfTimestamp(12346)));
 270
 271                 assertFalse("contains (low value)", range.contains(new TmfTimestamp(12340)));
 272                 assertFalse("contains (high value)", range.contains(new TmfTimestamp(12351)));
 273
 274         assertTrue("contains (zero)", range.contains(TmfTimestamp.Zero));
 275         }
 276
 277     public void testContainsRange() throws Exception {
 278         ITmfTimestamp ts1 = new TmfTimestamp(10);
 279         ITmfTimestamp ts2 = new TmfTimestamp(20);
 280         ITmfTimestamp ts3 = new TmfTimestamp(30);
 281         ITmfTimestamp ts4 = new TmfTimestamp(40);
 282         ITmfTimestamp ts5 = new TmfTimestamp(50);
 283         ITmfTimestamp ts6 = new TmfTimestamp(60);
 284         ITmfTimestamp ts7 = new TmfTimestamp(70);
 285         ITmfTimestamp ts8 = new TmfTimestamp(80);
 286
 287         // Reference range
 288         TmfTimeRange range0 = new TmfTimeRange(ts3, ts6);
 289
 290         // Start time below range
 291         TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
 292         TmfTimeRange range2 = new TmfTimeRange(ts2, ts3);
 293         TmfTimeRange range3 = new TmfTimeRange(ts2, ts4);
 294         TmfTimeRange range4 = new TmfTimeRange(ts2, ts6);
 295         TmfTimeRange range5 = new TmfTimeRange(ts2, ts7);
 296
 297         assertFalse("contains", range0.contains(range1));
 298         assertFalse("contains", range0.contains(range2));
 299         assertFalse("contains", range0.contains(range3));
 300         assertFalse("contains", range0.contains(range4));
 301         assertFalse("contains", range0.contains(range5));
 302
 303         // End time above range
 304         TmfTimeRange range6 = new TmfTimeRange(ts3, ts7);
 305         TmfTimeRange range7 = new TmfTimeRange(ts4, ts7);
 306         TmfTimeRange range8 = new TmfTimeRange(ts6, ts7);
 307         TmfTimeRange range9 = new TmfTimeRange(ts7, ts8);
 308
 309         assertFalse("contains", range0.contains(range6));
 310         assertFalse("contains", range0.contains(range7));
 311         assertFalse("contains", range0.contains(range8));
 312         assertFalse("contains", range0.contains(range9));
 313
 314         // Within range
 315         TmfTimeRange range10 = new TmfTimeRange(ts3, ts4);
 316         TmfTimeRange range11 = new TmfTimeRange(ts3, ts6);
 317         TmfTimeRange range12 = new TmfTimeRange(ts4, ts5);
 318         TmfTimeRange range13 = new TmfTimeRange(ts4, ts6);
 319
 320         assertTrue("contains", range0.contains(range10));
 321         assertTrue("contains", range0.contains(range11));
 322         assertTrue("contains", range0.contains(range12));
 323         assertTrue("contains", range0.contains(range13));
 324     }
 325
 326         // ------------------------------------------------------------------------
 327         // getIntersection
 328         // ------------------------------------------------------------------------
 329
 330         public void testGetIntersection() throws Exception {
 331
 332                 ITmfTimestamp ts1a = new TmfTimestamp(1000);
 333                 ITmfTimestamp ts1b = new TmfTimestamp(2000);
 334                 TmfTimeRange range1 = new TmfTimeRange(ts1a, ts1b);
 335
 336                 ITmfTimestamp ts2a = new TmfTimestamp(2000);
 337                 ITmfTimestamp ts2b = new TmfTimestamp(3000);
 338                 TmfTimeRange range2 = new TmfTimeRange(ts2a, ts2b);
 339
 340                 ITmfTimestamp ts3a = new TmfTimestamp(3000);
 341                 ITmfTimestamp ts3b = new TmfTimestamp(4000);
 342                 TmfTimeRange range3 = new TmfTimeRange(ts3a, ts3b);
 343
 344                 ITmfTimestamp ts4a = new TmfTimestamp(1500);
 345                 ITmfTimestamp ts4b = new TmfTimestamp(2500);
 346                 TmfTimeRange range4 = new TmfTimeRange(ts4a, ts4b);
 347
 348                 ITmfTimestamp ts5a = new TmfTimestamp(1500);
 349                 ITmfTimestamp ts5b = new TmfTimestamp(2000);
 350                 TmfTimeRange range5 = new TmfTimeRange(ts5a, ts5b);
 351
 352                 ITmfTimestamp ts6a = new TmfTimestamp(2000);
 353                 ITmfTimestamp ts6b = new TmfTimestamp(2500);
 354                 TmfTimeRange range6 = new TmfTimeRange(ts6a, ts6b);
 355
 356                 ITmfTimestamp ts7a = new TmfTimestamp(1500);
 357                 ITmfTimestamp ts7b = new TmfTimestamp(3500);
 358                 TmfTimeRange range7 = new TmfTimeRange(ts7a, ts7b);
 359
 360                 ITmfTimestamp ts8a = new TmfTimestamp(2250);
 361                 ITmfTimestamp ts8b = new TmfTimestamp(2750);
 362                 TmfTimeRange range8 = new TmfTimeRange(ts8a, ts8b);
 363
 364                 assertEquals("getIntersection (below - not contiguous)", null, range1.getIntersection(range3));
 365                 assertEquals("getIntersection (above - not contiguous)", null, range3.getIntersection(range1));
 366
 367                 assertEquals("getIntersection (below - contiguous)", new TmfTimeRange(ts1b, ts1b), range1.getIntersection(range2));
 368                 assertEquals("getIntersection (above - contiguous)", new TmfTimeRange(ts3a, ts3a), range3.getIntersection(range2));
 369
 370                 assertEquals("getIntersection (below - overlap)", new TmfTimeRange(ts2a, ts4b), range2.getIntersection(range4));
 371                 assertEquals("getIntersection (above - overlap)", new TmfTimeRange(ts2a, ts4b), range4.getIntersection(range2));
 372
 373                 assertEquals("getIntersection (within - overlap1)", range6, range2.getIntersection(range6));
 374                 assertEquals("getIntersection (within - overlap2)", range6, range6.getIntersection(range2));
 375
 376                 assertEquals("getIntersection (within - overlap3)", range5, range1.getIntersection(range5));
 377                 assertEquals("getIntersection (within - overlap4)", range5, range5.getIntersection(range1));
 378
 379                 assertEquals("getIntersection (within - overlap5)", range8, range2.getIntersection(range8));
 380                 assertEquals("getIntersection (within - overlap6)", range8, range8.getIntersection(range2));
 381
 382                 assertEquals("getIntersection (accross1)", range2, range2.getIntersection(range7));
 383                 assertEquals("getIntersection (accross2)", range2, range7.getIntersection(range2));
 384         }
 385
 386 }