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

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 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 - Adjusted for new Event Model
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.tests.event;
  15
  16 import java.io.File;
  17 import java.io.IOException;
  18 import java.net.URISyntaxException;
  19 import java.net.URL;
  20
  21 import junit.framework.TestCase;
  22
  23 import org.eclipse.core.runtime.FileLocator;
  24 import org.eclipse.core.runtime.Path;
  25 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  26 import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
  27 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  28 import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
  29 import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
  30 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  31 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
  32 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  33 import org.eclipse.linuxtools.tmf.stubs.trace.TmfTraceStub;
  34
  35 /**
  36  * <b><u>TmfEventTest</u></b>
  37  * <p>
  38  * Test suite for the TmfEvent class.
  39  */
  40 @SuppressWarnings("nls")
  41 public class TmfEventTest extends TestCase {
  42
  43     // ------------------------------------------------------------------------
  44     // Variables
  45     // ------------------------------------------------------------------------
  46
  47     private final String fSource = "Source";
  48
  49     private final String fContext = TmfEventType.DEFAULT_CONTEXT_ID;
  50     private final String fTypeId = "TestType";
  51     private final String fLabel1 = "AString";
  52     private final String fLabel2 = "AnInteger";
  53     private final String[] fLabels = new String[] { fLabel1, fLabel2 };
  54     private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
  55
  56     private final Object fValue1a = "Some string";
  57     private final Object fValue1b = Integer.valueOf(10);
  58     private final ITmfEventField fField1a = new TmfEventField(fLabel1, fValue1a);
  59     private final ITmfEventField fField1b = new TmfEventField(fLabel2, fValue1b);
  60     private final ITmfEventField[] fFields1 = new ITmfEventField[] { fField1a, fField1b };
  61     private final String fRawContent1 = fField1a.toString() + fField1b.toString();
  62     private final ITmfEventField fContent1 = new TmfEventField(fRawContent1, fFields1);
  63     private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, 2, 5);
  64     private final String fReference1 = "Some reference";
  65     private final TmfEvent fEvent1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
  66
  67     private final Object fValue2a = "Another string";
  68     private final Object fValue2b = Integer.valueOf(-4);
  69     private final ITmfEventField fField2a = new TmfEventField(fLabel1, fValue2a);
  70     private final ITmfEventField fField2b = new TmfEventField(fLabel2, fValue2b);
  71     private final ITmfEventField[] fFields2 = new ITmfEventField[] { fField2a, fField2b };
  72     private final String fRawContent2 = fField2a.toString() + fField2b.toString();
  73     private final ITmfEventField fContent2 = new TmfEventField(fRawContent2, fFields2);
  74     private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, 2, 5);
  75     private final String fReference2 = "Some other reference";
  76     private final TmfEvent fEvent2 = new TmfEvent(null, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
  77
  78     // ------------------------------------------------------------------------
  79     // Housekeeping
  80     // ------------------------------------------------------------------------
  81
  82     /**
  83      * @param name the test name
  84      */
  85     public TmfEventTest(String name) {
  86         super(name);
  87     }
  88
  89     @Override
  90     protected void setUp() throws Exception {
  91         super.setUp();
  92     }
  93
  94     @Override
  95     protected void tearDown() throws Exception {
  96         super.tearDown();
  97     }
  98
  99     // ------------------------------------------------------------------------
 100     // Helper functions
 101     // ------------------------------------------------------------------------
 102
 103     private TmfTraceStub openTrace() {
 104         String DIRECTORY = "testfiles";
 105         String TEST_STREAM = "A-Test-10K";
 106         String path = DIRECTORY + File.separator + TEST_STREAM;
 107
 108         TmfTraceStub trace = null;
 109         try {
 110             URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
 111             File test = new File(FileLocator.toFileURL(location).toURI());
 112             trace = new TmfTraceStub(test.toURI().getPath(), 500, false);
 113         } catch (URISyntaxException e) {
 114             e.printStackTrace();
 115         } catch (IOException e) {
 116             e.printStackTrace();
 117         }
 118         return trace;
 119     }
 120
 121     // ------------------------------------------------------------------------
 122     // Constructors
 123     // ------------------------------------------------------------------------
 124
 125     public void testDefaultConstructor() {
 126         ITmfEvent event = new TmfEvent();
 127         assertNull("getTrace", event.getTrace());
 128         assertEquals("getRank", -1, event.getRank());
 129         assertNull("getTimestamp", event.getTimestamp());
 130         assertNull("getSource", event.getSource());
 131         assertNull("getType", event.getType());
 132         assertNull("getContent", event.getContent());
 133         assertNull("getReference", event.getReference());
 134     }
 135
 136     public void testFullConstructor() {
 137         assertNull("getTrace", fEvent1.getTrace());
 138         assertEquals("getRank", 0, fEvent1.getRank());
 139         assertEquals("getTimestamp", fTimestamp1, fEvent1.getTimestamp());
 140         assertEquals("getSource", fSource, fEvent1.getSource());
 141         assertEquals("getType", fType, fEvent1.getType());
 142         assertEquals("getContent", fContent1, fEvent1.getContent());
 143         assertEquals("getReference", fReference1, fEvent1.getReference());
 144
 145         assertNull("getTrace", fEvent2.getTrace());
 146         assertEquals("getRank", 1, fEvent2.getRank());
 147         assertEquals("getTimestamp", fTimestamp2, fEvent2.getTimestamp());
 148         assertEquals("getSource", fSource, fEvent2.getSource());
 149         assertEquals("getType", fType, fEvent2.getType());
 150         assertEquals("getContent", fContent2, fEvent2.getContent());
 151         assertEquals("getReference", fReference2, fEvent2.getReference());
 152     }
 153
 154     public void testNoRankConstructor() {
 155         TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
 156         assertNull("getTrace", event.getTrace());
 157         assertEquals("getRank", -1, event.getRank());
 158         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 159         assertEquals("getSource", fSource, event.getSource());
 160         assertEquals("getType", fType, event.getType());
 161         assertEquals("getContent", fContent1, event.getContent());
 162         assertEquals("getReference", fReference1, event.getReference());
 163     }
 164
 165     public void testNoRankContentConstructor() {
 166         TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fReference1);
 167         assertNull("getTrace", event.getTrace());
 168         assertEquals("getRank", -1, event.getRank());
 169         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 170         assertEquals("getSource", fSource, event.getSource());
 171         assertEquals("getType", fType, event.getType());
 172         assertNull("getContent", event.getContent());
 173         assertEquals("getReference", fReference1, event.getReference());
 174     }
 175
 176     public void testNoTraceRankContentConstructor() {
 177         TmfEvent event = new TmfEvent(fTimestamp1, fSource, fType, fReference1);
 178         assertNull("getTrace", event.getTrace());
 179         assertEquals("getRank", -1, event.getRank());
 180         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 181         assertEquals("getSource", fSource, event.getSource());
 182         assertEquals("getType", fType, event.getType());
 183         assertNull("getContent", event.getContent());
 184         assertEquals("getReference", fReference1, event.getReference());
 185     }
 186
 187     public void testConstructorWithTrace() {
 188         ITmfTrace<TmfEvent> trace = openTrace();
 189         TmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 190         assertNotNull("getTrace", event.getTrace());
 191         assertEquals("getRank", 0, event.getRank());
 192         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 193         assertEquals("getSource", fSource, event.getSource());
 194         assertEquals("getType", fType, event.getType());
 195         assertEquals("getContent", fContent1, event.getContent());
 196         assertEquals("getReference", fReference1, event.getReference());
 197         trace.dispose();
 198     }
 199
 200     public void testTmfEventCopy() {
 201         TmfEvent event = new TmfEvent(fEvent1);
 202         assertNull("getTrace", event.getTrace());
 203         assertEquals("getRank", 0, event.getRank());
 204         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 205         assertEquals("getSource", fSource, event.getSource());
 206         assertEquals("getType", fType, event.getType());
 207         assertEquals("getContent", fContent1, event.getContent());
 208         assertEquals("getReference", fReference1, event.getReference());
 209     }
 210
 211     public void testEventCopy2() throws Exception {
 212         try {
 213             new TmfEvent(null);
 214             fail("null copy");
 215         } catch (IllegalArgumentException e) {
 216             // Success
 217         }
 218     }
 219
 220     // ------------------------------------------------------------------------
 221     // Setters
 222     // ------------------------------------------------------------------------
 223
 224     public void testSetSource() {
 225         TmfEvent event = new TmfEvent(fEvent1);
 226         assertEquals("setSource", fSource, event.getSource());
 227
 228         String source2 = "another source";
 229         event.setSource(source2);
 230         assertEquals("setContent", source2, event.getSource());
 231
 232         event.setSource(null);
 233         assertNull("setContent", event.getSource());
 234
 235         event.setSource(fSource);
 236         assertEquals("setContent", fSource, event.getSource());
 237     }
 238
 239     public void testSetTimestamp() {
 240         TmfEvent event = new TmfEvent(fEvent1);
 241         assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());
 242
 243         event.setTimestamp(fTimestamp2);
 244         assertEquals("setTimestamp", fTimestamp2, event.getTimestamp());
 245
 246         event.setTimestamp(null);
 247         assertNull("setTimestamp", event.getTimestamp());
 248
 249         event.setTimestamp(fTimestamp1);
 250         assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());
 251     }
 252
 253     public void testSetType() {
 254         TmfEvent event = new TmfEvent(fEvent1);
 255         assertEquals("setType", fType, event.getType());
 256
 257         String typeId = "OtherTestType";
 258         String[] labels = new String[] { fLabel2, fLabel1 };
 259         TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 260
 261         event.setType(newType);
 262         assertEquals("setType", newType, event.getType());
 263
 264         event.setType(null);
 265         assertNull("setType", event.getType());
 266
 267         event.setType(fType);
 268         assertEquals("setType", fType, event.getType());
 269     }
 270
 271     public void testSetContent() {
 272         TmfEvent event = new TmfEvent(fEvent1);
 273         assertEquals("setContent", fContent1, event.getContent());
 274
 275         event.setContent(fContent2);
 276         assertEquals("setContent", fContent2, event.getContent());
 277
 278         event.setContent(null);
 279         assertNull("setContent", event.getContent());
 280
 281         event.setContent(fContent1);
 282         assertEquals("setContent", fContent1, event.getContent());
 283     }
 284
 285     public void testSetReference() {
 286         TmfEvent event = new TmfEvent(fEvent1);
 287         assertEquals("setReference", fReference1, event.getReference());
 288
 289         event.setReference(fReference2);
 290         assertEquals("setReference", fReference2, event.getReference());
 291
 292         event.setReference(null);
 293         assertNull("setReference", event.getReference());
 294
 295         event.setReference(fReference1);
 296         assertEquals("setReference", fReference1, event.getReference());
 297     }
 298
 299     // ------------------------------------------------------------------------
 300     // clone
 301     // ------------------------------------------------------------------------
 302
 303     public static class MyEvent extends TmfEvent {
 304
 305         @Override
 306         public boolean equals(Object other) {
 307             return super.equals(other);
 308         }
 309         @Override
 310         public MyEvent clone() {
 311             return (MyEvent) super.clone();
 312         }
 313     }
 314
 315     public void testClone() throws Exception {
 316         ITmfEvent clone = fEvent1.clone();
 317         assertEquals("clone", fEvent1, clone);
 318     }
 319
 320     public void testClone2() throws Exception {
 321         ITmfEvent event = new MyEvent();
 322         ITmfEvent clone = event.clone();
 323         assertEquals("clone", clone, event);
 324     }
 325
 326     // ------------------------------------------------------------------------
 327     // hashCode
 328     // ------------------------------------------------------------------------
 329
 330     public void testHashCode() throws Exception {
 331         TmfEvent event1 = new TmfEvent();
 332         TmfEvent event2 = new TmfEvent();
 333
 334         assertTrue("hashCode", event1.hashCode() == event2.hashCode());
 335
 336         ITmfTrace<TmfEvent> trace = openTrace();
 337         event1 = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 338         event2 = new TmfEvent(trace, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
 339         TmfEvent event1b = new TmfEvent(event1);
 340         TmfEvent event2b = new TmfEvent(event2);
 341
 342         assertTrue("hashCode", event1.hashCode() == event1b.hashCode());
 343         assertTrue("hashCode", event2.hashCode() == event2b.hashCode());
 344
 345         assertTrue("hashCode", event1.hashCode() != event2.hashCode());
 346         assertTrue("hashCode", event2.hashCode() != event1.hashCode());
 347
 348         trace.dispose();
 349     }
 350
 351     // ------------------------------------------------------------------------
 352     // equals
 353     // ------------------------------------------------------------------------
 354
 355     public void testEqualsReflexivity() throws Exception {
 356         assertTrue("equals", fEvent1.equals(fEvent1));
 357         assertTrue("equals", fEvent2.equals(fEvent2));
 358
 359         assertFalse("equals", fEvent1.equals(fEvent2));
 360         assertFalse("equals", fEvent2.equals(fEvent1));
 361     }
 362
 363     public void testEqualsSymmetry() throws Exception {
 364         TmfEvent event1 = new TmfEvent(fEvent1);
 365         TmfEvent event2 = new TmfEvent(fEvent2);
 366
 367         assertTrue("equals", event1.equals(fEvent1));
 368         assertTrue("equals", fEvent1.equals(event1));
 369
 370         assertTrue("equals", event2.equals(fEvent2));
 371         assertTrue("equals", fEvent2.equals(event2));
 372     }
 373
 374     public void testEqualsTransivity() throws Exception {
 375         TmfEvent event1 = new TmfEvent(fEvent1);
 376         TmfEvent event2 = new TmfEvent(fEvent1);
 377         TmfEvent event3 = new TmfEvent(fEvent1);
 378
 379         assertTrue("equals", event1.equals(event2));
 380         assertTrue("equals", event2.equals(event3));
 381         assertTrue("equals", event1.equals(event3));
 382     }
 383
 384     public void testEqualsNull() throws Exception {
 385         assertFalse("equals", fEvent1.equals(null));
 386         assertFalse("equals", fEvent2.equals(null));
 387     }
 388
 389     public void testNonEqualClasses() throws Exception {
 390         assertFalse("equals", fEvent1.equals(fEvent1.getType()));
 391         assertFalse("equals", fEvent1.equals(null));
 392     }
 393
 394     public void testNonEqualTraces() throws Exception {
 395         ITmfTrace<TmfEvent> trace1 = openTrace();
 396         ITmfTrace<TmfEvent> trace2 = openTrace();
 397
 398         TmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 399         TmfEvent event2 = new TmfEvent(trace1,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 400         assertTrue("equals", event1.equals(event2));
 401         assertTrue("equals", event2.equals(event1));
 402
 403         event2 = new TmfEvent(null,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 404         assertFalse("equals", event1.equals(event2));
 405         assertFalse("equals", event2.equals(event1));
 406
 407         event2 = new TmfEvent(trace2,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 408         assertFalse("equals", event1.equals(event2));
 409         assertFalse("equals", event2.equals(event1));
 410
 411         trace1.dispose();
 412         trace2.dispose();
 413     }
 414
 415     public void testNonEqualRanks() throws Exception {
 416         TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 417         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 418         assertTrue("equals", event1.equals(event2));
 419         assertTrue("equals", event2.equals(event1));
 420
 421         event2 = new TmfEvent(null, 1, fTimestamp1, fSource, fType, fContent1, fReference1);
 422         assertFalse("equals", event1.equals(event2));
 423         assertFalse("equals", event2.equals(event1));
 424     }
 425
 426     public void testNonEqualTimestamps() throws Exception {
 427         TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 428         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 429         assertTrue("equals", event1.equals(event2));
 430         assertTrue("equals", event2.equals(event1));
 431
 432         event2 = new TmfEvent(null, 0, fTimestamp2, fSource, fType, fContent1, fReference1);
 433         assertFalse("equals", event1.equals(event2));
 434         assertFalse("equals", event2.equals(event1));
 435
 436         event2 = new TmfEvent(null, 0, null, fSource, fType, fContent1, fReference1);
 437         assertFalse("equals", event1.equals(event2));
 438         assertFalse("equals", event2.equals(event1));
 439     }
 440
 441     public void testNonEqualSources() throws Exception {
 442         TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 443         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 444         assertTrue("equals", event1.equals(event2));
 445         assertTrue("equals", event2.equals(event1));
 446
 447         event2 = new TmfEvent(null, 0, fTimestamp1, fSource + "x", fType, fContent1, fReference1);
 448         assertFalse("equals", event1.equals(event2));
 449         assertFalse("equals", event2.equals(event1));
 450
 451         event2 = new TmfEvent(null, 0, fTimestamp1, null, fType, fContent1, fReference1);
 452         assertFalse("equals", event1.equals(event2));
 453         assertFalse("equals", event2.equals(event1));
 454     }
 455
 456     public void testNonEqualTypes() throws Exception {
 457         TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 458         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType,  fContent1, fReference1);
 459         assertTrue("equals", event1.equals(event2));
 460         assertTrue("equals", event2.equals(event1));
 461
 462         String typeId = "OtherTestType";
 463         String[] labels = new String[] { fLabel2, fLabel1 };
 464         TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 465
 466         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, newType, fContent1, fReference1);
 467         assertFalse("equals", event1.equals(event2));
 468         assertFalse("equals", event2.equals(event1));
 469
 470         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, null, fContent1, fReference1);
 471         assertFalse("equals", event1.equals(event2));
 472         assertFalse("equals", event2.equals(event1));
 473     }
 474
 475     public void testNonEqualContents() throws Exception {
 476         TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 477         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 478         assertTrue("equals", event1.equals(event2));
 479         assertTrue("equals", event2.equals(event1));
 480
 481         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent2, fReference1);
 482         assertFalse("equals", event1.equals(event2));
 483         assertFalse("equals", event2.equals(event1));
 484
 485         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, null, fReference1);
 486         assertFalse("equals", event1.equals(event2));
 487         assertFalse("equals", event2.equals(event1));
 488     }
 489
 490     public void testNonEqualReferences() throws Exception {
 491         TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 492         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 493         assertTrue("equals", event1.equals(event2));
 494         assertTrue("equals", event2.equals(event1));
 495
 496         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference2);
 497         assertFalse("equals", event1.equals(event2));
 498         assertFalse("equals", event2.equals(event1));
 499
 500         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, null);
 501         assertFalse("equals", event1.equals(event2));
 502         assertFalse("equals", event2.equals(event1));
 503     }
 504
 505     // ------------------------------------------------------------------------
 506     // toString
 507     // ------------------------------------------------------------------------
 508
 509     public void testToString() {
 510         String expected1 = "TmfEvent [fTimestamp=" + fTimestamp1 + ", fTrace=null, fRank=0, fSource=" + fSource
 511                 + ", fType=" + fType + ", fContent=" + fContent1 + ", fReference=" + fReference1 + "]";
 512         assertEquals("toString", expected1, fEvent1.toString());
 513
 514         String expected2 = "TmfEvent [fTimestamp=" + fTimestamp2 + ", fTrace=null, fRank=1, fSource=" + fSource
 515                 + ", fType=" + fType + ", fContent=" + fContent2 + ", fReference=" + fReference2 + "]";
 516         assertEquals("toString", expected2, fEvent2.toString());
 517     }
 518
 519 }