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.ITmfEventType;
  28 import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
  29 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  30 import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
  31 import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
  32 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  33 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  34 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
  35 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  36 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  37 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  38
  39 /**
  40  * Test suite for the TmfEvent class.
  41  */
  42 @SuppressWarnings("nls")
  43 public class TmfEventTest extends TestCase {
  44
  45     // ------------------------------------------------------------------------
  46     // Variables
  47     // ------------------------------------------------------------------------
  48
  49     private final String fSource = "Source";
  50
  51     private final String fContext = ITmfEventType.DEFAULT_CONTEXT_ID;
  52     private final String fTypeId = "TestType";
  53     private final String fLabel1 = "AString";
  54     private final String fLabel2 = "AnInteger";
  55     private final String[] fLabels = new String[] { fLabel1, fLabel2 };
  56     private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
  57
  58     private final Object fValue1a = "Some string";
  59     private final Object fValue1b = Integer.valueOf(10);
  60     private final ITmfEventField fField1a = new TmfEventField(fLabel1, fValue1a);
  61     private final ITmfEventField fField1b = new TmfEventField(fLabel2, fValue1b);
  62     private final ITmfEventField[] fFields1 = new ITmfEventField[] { fField1a, fField1b };
  63     private final String fRawContent1 = fField1a.toString() + fField1b.toString();
  64     private final ITmfEventField fContent1 = new TmfEventField(fRawContent1, fFields1);
  65     private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, 2, 5);
  66     private final String fReference1 = "Some reference";
  67     private final ITmfEvent fEvent1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
  68
  69     private final Object fValue2a = "Another string";
  70     private final Object fValue2b = Integer.valueOf(-4);
  71     private final ITmfEventField fField2a = new TmfEventField(fLabel1, fValue2a);
  72     private final ITmfEventField fField2b = new TmfEventField(fLabel2, fValue2b);
  73     private final ITmfEventField[] fFields2 = new ITmfEventField[] { fField2a, fField2b };
  74     private final String fRawContent2 = fField2a.toString() + fField2b.toString();
  75     private final ITmfEventField fContent2 = new TmfEventField(fRawContent2, fFields2);
  76     private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, 2, 5);
  77     private final String fReference2 = "Some other reference";
  78     private final ITmfEvent fEvent2 = new TmfEvent(null, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
  79
  80     private final String fTracePath = "testfiles" + File.separator + "A-Test-10K";
  81
  82     // ------------------------------------------------------------------------
  83     // Housekeeping
  84     // ------------------------------------------------------------------------
  85
  86     /**
  87      * @param name the test name
  88      */
  89     public TmfEventTest(final String name) {
  90         super(name);
  91     }
  92
  93     @Override
  94     protected void setUp() throws Exception {
  95         super.setUp();
  96     }
  97
  98     @Override
  99     protected void tearDown() throws Exception {
 100         super.tearDown();
 101     }
 102
 103     // ------------------------------------------------------------------------
 104     // Helper functions
 105     // ------------------------------------------------------------------------
 106
 107     private static TmfTraceStub openTrace() {
 108         final String DIRECTORY = "testfiles";
 109         final String TEST_STREAM = "A-Test-10K";
 110         final String path = DIRECTORY + File.separator + TEST_STREAM;
 111
 112         TmfTraceStub trace = null;
 113         try {
 114             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
 115             final File test = new File(FileLocator.toFileURL(location).toURI());
 116             trace = new TmfTraceStub(test.toURI().getPath(), 500, false);
 117         } catch (final TmfTraceException e) {
 118             e.printStackTrace();
 119         } catch (final URISyntaxException e) {
 120             e.printStackTrace();
 121         } catch (final IOException e) {
 122             e.printStackTrace();
 123         }
 124         return trace;
 125     }
 126
 127     // ------------------------------------------------------------------------
 128     // Constructors
 129     // ------------------------------------------------------------------------
 130
 131     /**
 132      *
 133      */
 134     public void testDefaultConstructor() {
 135         final ITmfEvent event = new TmfEvent();
 136         assertNull("getTrace", event.getTrace());
 137         assertEquals("getRank", ITmfContext.UNKNOWN_RANK, event.getRank());
 138         assertNull("getTimestamp", event.getTimestamp());
 139         assertNull("getSource", event.getSource());
 140         assertNull("getType", event.getType());
 141         assertNull("getContent", event.getContent());
 142         assertNull("getReference", event.getReference());
 143     }
 144
 145     /**
 146      *
 147      */
 148     public void testFullConstructor() {
 149         assertNull("getTrace", fEvent1.getTrace());
 150         assertEquals("getRank", 0, fEvent1.getRank());
 151         assertEquals("getTimestamp", fTimestamp1, fEvent1.getTimestamp());
 152         assertEquals("getSource", fSource, fEvent1.getSource());
 153         assertEquals("getType", fType, fEvent1.getType());
 154         assertEquals("getContent", fContent1, fEvent1.getContent());
 155         assertEquals("getReference", fReference1, fEvent1.getReference());
 156
 157         assertNull("getTrace", fEvent2.getTrace());
 158         assertEquals("getRank", 1, fEvent2.getRank());
 159         assertEquals("getTimestamp", fTimestamp2, fEvent2.getTimestamp());
 160         assertEquals("getSource", fSource, fEvent2.getSource());
 161         assertEquals("getType", fType, fEvent2.getType());
 162         assertEquals("getContent", fContent2, fEvent2.getContent());
 163         assertEquals("getReference", fReference2, fEvent2.getReference());
 164     }
 165
 166     /**
 167      *
 168      */
 169     public void testNoRankConstructor() {
 170         final TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
 171         assertNull("getTrace", event.getTrace());
 172         assertEquals("getRank", ITmfContext.UNKNOWN_RANK, event.getRank());
 173         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 174         assertEquals("getSource", fSource, event.getSource());
 175         assertEquals("getType", fType, event.getType());
 176         assertEquals("getContent", fContent1, event.getContent());
 177         assertEquals("getReference", fReference1, event.getReference());
 178     }
 179
 180     /**
 181      *
 182      */
 183     public void testConstructorWithTrace() {
 184         final ITmfTrace trace = openTrace();
 185         final TmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 186         assertNotNull("getTrace", event.getTrace());
 187         assertEquals("getRank", 0, event.getRank());
 188         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 189         assertEquals("getSource", fSource, event.getSource());
 190         assertEquals("getType", fType, event.getType());
 191         assertEquals("getContent", fContent1, event.getContent());
 192         assertEquals("getReference", fReference1, event.getReference());
 193         trace.dispose();
 194     }
 195
 196     /**
 197      *
 198      */
 199     public void testTmfEventCopy() {
 200         final TmfEvent event = new TmfEvent(fEvent1);
 201         assertNull("getTrace", event.getTrace());
 202         assertEquals("getRank", 0, event.getRank());
 203         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 204         assertEquals("getSource", fSource, event.getSource());
 205         assertEquals("getType", fType, event.getType());
 206         assertEquals("getContent", fContent1, event.getContent());
 207         assertEquals("getReference", fReference1, event.getReference());
 208     }
 209
 210     /**
 211      *
 212      */
 213     public void testEventCopy2() {
 214         try {
 215             new TmfEvent(null);
 216             fail("null copy");
 217         } catch (final IllegalArgumentException e) {
 218             // Success
 219         }
 220     }
 221
 222     // ------------------------------------------------------------------------
 223     // Setters
 224     // ------------------------------------------------------------------------
 225
 226     private static class TestEvent extends TmfEvent {
 227
 228         public TestEvent(final ITmfEvent event) {
 229             super(event);
 230         }
 231
 232         @Override
 233         public void setTrace(final ITmfTrace trace) {
 234             super.setTrace(trace);
 235         }
 236
 237         @Override
 238         public void setRank(final long rank) {
 239             super.setRank(rank);
 240         }
 241
 242         @Override
 243         public void setTimestamp(final ITmfTimestamp timestamp) {
 244             super.setTimestamp(timestamp);
 245         }
 246
 247         @Override
 248         public void setSource(final String source) {
 249             super.setSource(source);
 250         }
 251
 252         @Override
 253         public void setType(final ITmfEventType type) {
 254             super.setType(type);
 255         }
 256
 257         @Override
 258         public void setContent(final ITmfEventField content) {
 259             super.setContent(content);
 260         }
 261
 262         @Override
 263         public void setReference(final String reference) {
 264             super.setReference(reference);
 265         }
 266
 267     }
 268
 269     private ITmfTrace setupTrace() {
 270         ITmfTrace trace = null;
 271         try {
 272             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(fTracePath), null);
 273             final File test = new File(FileLocator.toFileURL(location).toURI());
 274             trace = new TmfTraceStub(test.toURI().getPath(), 500, false);
 275         } catch (final TmfTraceException e) {
 276             e.printStackTrace();
 277         } catch (final URISyntaxException e) {
 278             e.printStackTrace();
 279         } catch (final IOException e) {
 280             e.printStackTrace();
 281         }
 282         return trace;
 283     }
 284
 285     /**
 286      *
 287      */
 288     public void testSetTrace() {
 289         final ITmfTrace trace = setupTrace();
 290         assertNotNull(trace);
 291
 292         final TestEvent event = new TestEvent(fEvent1);
 293         assertNull("setTrace", event.getTrace());
 294
 295         event.setTrace(trace);
 296         assertEquals("setTrace", trace, event.getTrace());
 297
 298         event.setTrace(null);
 299         assertNull("setTrace", event.getTrace());
 300
 301         trace.dispose();
 302     }
 303
 304     /**
 305      *
 306      */
 307     public void testSetRank() {
 308         final TestEvent event = new TestEvent(fEvent1);
 309         assertEquals("setRank", 0, event.getRank());
 310
 311         event.setRank(1);
 312         assertEquals("setRank", 1, event.getRank());
 313
 314         event.setRank(-1);
 315         assertEquals("setRank", -1, event.getRank());
 316
 317         event.setRank(0);
 318         assertEquals("setRank", 0, event.getRank());
 319     }
 320
 321     /**
 322      *
 323      */
 324     public void testSetTimestamp() {
 325         final TestEvent event = new TestEvent(fEvent1);
 326         assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());
 327
 328         event.setTimestamp(fTimestamp2);
 329         assertEquals("setTimestamp", fTimestamp2, event.getTimestamp());
 330
 331         event.setTimestamp(null);
 332         assertNull("setTimestamp", event.getTimestamp());
 333
 334         event.setTimestamp(fTimestamp1);
 335         assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());
 336     }
 337
 338     /**
 339      *
 340      */
 341     public void testSetSource() {
 342         final TestEvent event = new TestEvent(fEvent1);
 343         assertEquals("setSource", fSource, event.getSource());
 344
 345         final String source2 = "another source";
 346         event.setSource(source2);
 347         assertEquals("setContent", source2, event.getSource());
 348
 349         event.setSource(null);
 350         assertNull("setContent", event.getSource());
 351
 352         event.setSource(fSource);
 353         assertEquals("setContent", fSource, event.getSource());
 354     }
 355
 356     /**
 357      *
 358      */
 359     public void testSetType() {
 360         final TestEvent event = new TestEvent(fEvent1);
 361         assertEquals("setType", fType, event.getType());
 362
 363         final String typeId = "OtherTestType";
 364         final String[] labels = new String[] { fLabel2, fLabel1 };
 365         final TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 366
 367         event.setType(newType);
 368         assertEquals("setType", newType, event.getType());
 369
 370         event.setType(null);
 371         assertNull("setType", event.getType());
 372
 373         event.setType(fType);
 374         assertEquals("setType", fType, event.getType());
 375     }
 376
 377     /**
 378      *
 379      */
 380     public void testSetContent() {
 381         final TestEvent event = new TestEvent(fEvent1);
 382         assertEquals("setContent", fContent1, event.getContent());
 383
 384         event.setContent(fContent2);
 385         assertEquals("setContent", fContent2, event.getContent());
 386
 387         event.setContent(null);
 388         assertNull("setContent", event.getContent());
 389
 390         event.setContent(fContent1);
 391         assertEquals("setContent", fContent1, event.getContent());
 392     }
 393
 394     /**
 395      *
 396      */
 397     public void testSetReference() {
 398         final TestEvent event = new TestEvent(fEvent1);
 399         assertEquals("setReference", fReference1, event.getReference());
 400
 401         event.setReference(fReference2);
 402         assertEquals("setReference", fReference2, event.getReference());
 403
 404         event.setReference(null);
 405         assertNull("setReference", event.getReference());
 406
 407         event.setReference(fReference1);
 408         assertEquals("setReference", fReference1, event.getReference());
 409     }
 410
 411     // ------------------------------------------------------------------------
 412     // clone
 413     // ------------------------------------------------------------------------
 414
 415     private static class MyEvent extends TmfEvent {
 416
 417         @Override
 418         public boolean equals(final Object other) {
 419             return super.equals(other);
 420         }
 421         @Override
 422         public MyEvent clone() {
 423             return (MyEvent) super.clone();
 424         }
 425     }
 426
 427     /**
 428      *
 429      */
 430     public void testClone1() {
 431         final ITmfEvent clone = fEvent1.clone();
 432
 433         assertTrue("clone", fEvent1.clone().equals(fEvent1));
 434         assertTrue("clone", clone.clone().equals(clone));
 435
 436         assertEquals("clone", fEvent1, clone);
 437         assertEquals("clone", clone, fEvent1);
 438     }
 439
 440     /**
 441      *
 442      */
 443     public void testClone2() {
 444         final TmfEvent event = new MyEvent();
 445         final TmfEvent clone = event.clone();
 446
 447         assertTrue("clone", event.clone().equals(event));
 448         assertTrue("clone", clone.clone().equals(clone));
 449
 450         assertEquals("clone", event, clone);
 451         assertEquals("clone", clone, event);
 452     }
 453
 454     // ------------------------------------------------------------------------
 455     // hashCode
 456     // ------------------------------------------------------------------------
 457
 458     /**
 459      *
 460      */
 461     public void testHashCode() {
 462         TmfEvent event1 = new TmfEvent();
 463         TmfEvent event2 = new TmfEvent();
 464
 465         assertTrue("hashCode", event1.hashCode() == event2.hashCode());
 466
 467         final ITmfTrace trace = openTrace();
 468         event1 = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 469         event2 = new TmfEvent(trace, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
 470         final TmfEvent event1b = new TmfEvent(event1);
 471         final TmfEvent event2b = new TmfEvent(event2);
 472
 473         assertTrue("hashCode", event1.hashCode() == event1b.hashCode());
 474         assertTrue("hashCode", event2.hashCode() == event2b.hashCode());
 475
 476         assertTrue("hashCode", event1.hashCode() != event2.hashCode());
 477         assertTrue("hashCode", event2.hashCode() != event1.hashCode());
 478
 479         trace.dispose();
 480     }
 481
 482     // ------------------------------------------------------------------------
 483     // equals
 484     // ------------------------------------------------------------------------
 485
 486     /**
 487      *
 488      */
 489     public void testEqualsReflexivity() {
 490         assertTrue("equals", fEvent1.equals(fEvent1));
 491         assertTrue("equals", fEvent2.equals(fEvent2));
 492
 493         assertFalse("equals", fEvent1.equals(fEvent2));
 494         assertFalse("equals", fEvent2.equals(fEvent1));
 495     }
 496
 497     /**
 498      *
 499      */
 500     public void testEqualsSymmetry() {
 501         final TmfEvent event1 = new TmfEvent(fEvent1);
 502         final TmfEvent event2 = new TmfEvent(fEvent2);
 503
 504         assertTrue("equals", event1.equals(fEvent1));
 505         assertTrue("equals", fEvent1.equals(event1));
 506
 507         assertTrue("equals", event2.equals(fEvent2));
 508         assertTrue("equals", fEvent2.equals(event2));
 509     }
 510
 511     /**
 512      *
 513      */
 514     public void testEqualsTransivity() {
 515         final TmfEvent event1 = new TmfEvent(fEvent1);
 516         final TmfEvent event2 = new TmfEvent(fEvent1);
 517         final TmfEvent event3 = new TmfEvent(fEvent1);
 518
 519         assertTrue("equals", event1.equals(event2));
 520         assertTrue("equals", event2.equals(event3));
 521         assertTrue("equals", event1.equals(event3));
 522     }
 523
 524     /**
 525      *
 526      */
 527     public void testEqualsNull() {
 528         assertFalse("equals", fEvent1.equals(null));
 529         assertFalse("equals", fEvent2.equals(null));
 530     }
 531
 532     /**
 533      *
 534      */
 535     public void testNonEqualClasses() {
 536         assertFalse("equals", fEvent1.equals(fEvent1.getType()));
 537         assertFalse("equals", fEvent1.equals(null));
 538     }
 539
 540     /**
 541      *
 542      */
 543     public void testNonEqualTraces() {
 544         final ITmfTrace trace1 = openTrace();
 545         final ITmfTrace trace2 = openTrace();
 546
 547         final TmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 548         TmfEvent event2 = new TmfEvent(trace1,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 549         assertTrue("equals", event1.equals(event2));
 550         assertTrue("equals", event2.equals(event1));
 551
 552         event2 = new TmfEvent(null,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 553         assertFalse("equals", event1.equals(event2));
 554         assertFalse("equals", event2.equals(event1));
 555
 556         event2 = new TmfEvent(trace2,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 557         assertFalse("equals", event1.equals(event2));
 558         assertFalse("equals", event2.equals(event1));
 559
 560         trace1.dispose();
 561         trace2.dispose();
 562     }
 563
 564     /**
 565      *
 566      */
 567     public void testNonEqualRanks() {
 568         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 569         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 570         assertTrue("equals", event1.equals(event2));
 571         assertTrue("equals", event2.equals(event1));
 572
 573         event2 = new TmfEvent(null, 1, fTimestamp1, fSource, fType, fContent1, fReference1);
 574         assertFalse("equals", event1.equals(event2));
 575         assertFalse("equals", event2.equals(event1));
 576     }
 577
 578     /**
 579      *
 580      */
 581     public void testNonEqualTimestamps() {
 582         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 583         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 584         assertTrue("equals", event1.equals(event2));
 585         assertTrue("equals", event2.equals(event1));
 586
 587         event2 = new TmfEvent(null, 0, fTimestamp2, fSource, fType, fContent1, fReference1);
 588         assertFalse("equals", event1.equals(event2));
 589         assertFalse("equals", event2.equals(event1));
 590
 591         event2 = new TmfEvent(null, 0, null, fSource, fType, fContent1, fReference1);
 592         assertFalse("equals", event1.equals(event2));
 593         assertFalse("equals", event2.equals(event1));
 594     }
 595
 596     /**
 597      *
 598      */
 599     public void testNonEqualSources() {
 600         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 601         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 602         assertTrue("equals", event1.equals(event2));
 603         assertTrue("equals", event2.equals(event1));
 604
 605         event2 = new TmfEvent(null, 0, fTimestamp1, fSource + "x", fType, fContent1, fReference1);
 606         assertFalse("equals", event1.equals(event2));
 607         assertFalse("equals", event2.equals(event1));
 608
 609         event2 = new TmfEvent(null, 0, fTimestamp1, null, fType, fContent1, fReference1);
 610         assertFalse("equals", event1.equals(event2));
 611         assertFalse("equals", event2.equals(event1));
 612     }
 613
 614     /**
 615      *
 616      */
 617     public void testNonEqualTypes() {
 618         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 619         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType,  fContent1, fReference1);
 620         assertTrue("equals", event1.equals(event2));
 621         assertTrue("equals", event2.equals(event1));
 622
 623         final String typeId = "OtherTestType";
 624         final String[] labels = new String[] { fLabel2, fLabel1 };
 625         final TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 626
 627         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, newType, fContent1, fReference1);
 628         assertFalse("equals", event1.equals(event2));
 629         assertFalse("equals", event2.equals(event1));
 630
 631         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, null, fContent1, fReference1);
 632         assertFalse("equals", event1.equals(event2));
 633         assertFalse("equals", event2.equals(event1));
 634     }
 635
 636     /**
 637      *
 638      */
 639     public void testNonEqualContents() {
 640         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 641         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 642         assertTrue("equals", event1.equals(event2));
 643         assertTrue("equals", event2.equals(event1));
 644
 645         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent2, fReference1);
 646         assertFalse("equals", event1.equals(event2));
 647         assertFalse("equals", event2.equals(event1));
 648
 649         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, null, fReference1);
 650         assertFalse("equals", event1.equals(event2));
 651         assertFalse("equals", event2.equals(event1));
 652     }
 653
 654     /**
 655      *
 656      */
 657     public void testNonEqualReferences() {
 658         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 659         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 660         assertTrue("equals", event1.equals(event2));
 661         assertTrue("equals", event2.equals(event1));
 662
 663         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference2);
 664         assertFalse("equals", event1.equals(event2));
 665         assertFalse("equals", event2.equals(event1));
 666
 667         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, null);
 668         assertFalse("equals", event1.equals(event2));
 669         assertFalse("equals", event2.equals(event1));
 670     }
 671
 672     // ------------------------------------------------------------------------
 673     // toString
 674     // ------------------------------------------------------------------------
 675
 676     /**
 677      *
 678      */
 679     public void testToString() {
 680         final String expected1 = "TmfEvent [fTimestamp=" + fTimestamp1 + ", fTrace=null, fRank=0, fSource=" + fSource
 681                 + ", fType=" + fType + ", fContent=" + fContent1 + ", fReference=" + fReference1 + "]";
 682         assertEquals("toString", expected1, fEvent1.toString());
 683
 684         final String expected2 = "TmfEvent [fTimestamp=" + fTimestamp2 + ", fTrace=null, fRank=1, fSource=" + fSource
 685                 + ", fType=" + fType + ", fContent=" + fContent2 + ", fReference=" + fReference2 + "]";
 686         assertEquals("toString", expected2, fEvent2.toString());
 687     }
 688
 689 }