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.ITmfTrace;
  36 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
  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 = TmfEventType.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 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     public void testDefaultConstructor() {
 132         final ITmfEvent event = new TmfEvent();
 133         assertNull("getTrace", event.getTrace());
 134         assertEquals("getRank", TmfContext.UNKNOWN_RANK, event.getRank());
 135         assertNull("getTimestamp", event.getTimestamp());
 136         assertNull("getSource", event.getSource());
 137         assertNull("getType", event.getType());
 138         assertNull("getContent", event.getContent());
 139         assertNull("getReference", event.getReference());
 140     }
 141
 142     public void testFullConstructor() {
 143         assertNull("getTrace", fEvent1.getTrace());
 144         assertEquals("getRank", 0, fEvent1.getRank());
 145         assertEquals("getTimestamp", fTimestamp1, fEvent1.getTimestamp());
 146         assertEquals("getSource", fSource, fEvent1.getSource());
 147         assertEquals("getType", fType, fEvent1.getType());
 148         assertEquals("getContent", fContent1, fEvent1.getContent());
 149         assertEquals("getReference", fReference1, fEvent1.getReference());
 150
 151         assertNull("getTrace", fEvent2.getTrace());
 152         assertEquals("getRank", 1, fEvent2.getRank());
 153         assertEquals("getTimestamp", fTimestamp2, fEvent2.getTimestamp());
 154         assertEquals("getSource", fSource, fEvent2.getSource());
 155         assertEquals("getType", fType, fEvent2.getType());
 156         assertEquals("getContent", fContent2, fEvent2.getContent());
 157         assertEquals("getReference", fReference2, fEvent2.getReference());
 158     }
 159
 160     public void testNoRankConstructor() {
 161         final TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
 162         assertNull("getTrace", event.getTrace());
 163         assertEquals("getRank", TmfContext.UNKNOWN_RANK, event.getRank());
 164         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 165         assertEquals("getSource", fSource, event.getSource());
 166         assertEquals("getType", fType, event.getType());
 167         assertEquals("getContent", fContent1, event.getContent());
 168         assertEquals("getReference", fReference1, event.getReference());
 169     }
 170
 171     public void testConstructorWithTrace() {
 172         final ITmfTrace<TmfEvent> trace = openTrace();
 173         final TmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 174         assertNotNull("getTrace", event.getTrace());
 175         assertEquals("getRank", 0, event.getRank());
 176         assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
 177         assertEquals("getSource", fSource, event.getSource());
 178         assertEquals("getType", fType, event.getType());
 179         assertEquals("getContent", fContent1, event.getContent());
 180         assertEquals("getReference", fReference1, event.getReference());
 181         trace.dispose();
 182     }
 183
 184     public void testTmfEventCopy() {
 185         final TmfEvent event = new TmfEvent(fEvent1);
 186         assertNull("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     }
 194
 195     public void testEventCopy2() throws Exception {
 196         try {
 197             new TmfEvent(null);
 198             fail("null copy");
 199         } catch (final IllegalArgumentException e) {
 200             // Success
 201         }
 202     }
 203
 204     // ------------------------------------------------------------------------
 205     // Setters
 206     // ------------------------------------------------------------------------
 207
 208     private static class TestEvent extends TmfEvent {
 209
 210         public TestEvent(final ITmfEvent event) {
 211             super(event);
 212         }
 213
 214         @Override
 215         public void setTrace(final ITmfTrace<? extends ITmfEvent> trace) {
 216             super.setTrace(trace);
 217         }
 218
 219         @Override
 220         public void setRank(final long rank) {
 221             super.setRank(rank);
 222         }
 223
 224         @Override
 225         public void setTimestamp(final ITmfTimestamp timestamp) {
 226             super.setTimestamp(timestamp);
 227         }
 228
 229         @Override
 230         public void setSource(final String source) {
 231             super.setSource(source);
 232         }
 233
 234         @Override
 235         public void setType(final ITmfEventType type) {
 236             super.setType(type);
 237         }
 238
 239         @Override
 240         public void setContent(final ITmfEventField content) {
 241             super.setContent(content);
 242         }
 243
 244         @Override
 245         public void setReference(final String reference) {
 246             super.setReference(reference);
 247         }
 248
 249     }
 250
 251     private ITmfTrace<TmfEvent> setupTrace() {
 252         ITmfTrace<TmfEvent> trace = null;
 253         try {
 254             final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(fTracePath), null);
 255             final File test = new File(FileLocator.toFileURL(location).toURI());
 256             trace = new TmfTraceStub(test.toURI().getPath(), 500, false);
 257         } catch (final TmfTraceException e) {
 258             e.printStackTrace();
 259         } catch (final URISyntaxException e) {
 260             e.printStackTrace();
 261         } catch (final IOException e) {
 262             e.printStackTrace();
 263         }
 264         return trace;
 265     }
 266
 267     public void testSetTrace() {
 268         final ITmfTrace<TmfEvent> trace = setupTrace();
 269         assertNotNull(trace);
 270
 271         final TestEvent event = new TestEvent(fEvent1);
 272         assertNull("setTrace", event.getTrace());
 273
 274         event.setTrace(trace);
 275         assertEquals("setTrace", trace, event.getTrace());
 276
 277         event.setTrace(null);
 278         assertNull("setTrace", event.getTrace());
 279
 280         trace.dispose();
 281     }
 282
 283     public void testSetRank() {
 284         final TestEvent event = new TestEvent(fEvent1);
 285         assertEquals("setRank", 0, event.getRank());
 286
 287         event.setRank(1);
 288         assertEquals("setRank", 1, event.getRank());
 289
 290         event.setRank(-1);
 291         assertEquals("setRank", -1, event.getRank());
 292
 293         event.setRank(0);
 294         assertEquals("setRank", 0, event.getRank());
 295     }
 296
 297     public void testSetTimestamp() {
 298         final TestEvent event = new TestEvent(fEvent1);
 299         assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());
 300
 301         event.setTimestamp(fTimestamp2);
 302         assertEquals("setTimestamp", fTimestamp2, event.getTimestamp());
 303
 304         event.setTimestamp(null);
 305         assertNull("setTimestamp", event.getTimestamp());
 306
 307         event.setTimestamp(fTimestamp1);
 308         assertEquals("setTimestamp", fTimestamp1, event.getTimestamp());
 309     }
 310
 311     public void testSetSource() {
 312         final TestEvent event = new TestEvent(fEvent1);
 313         assertEquals("setSource", fSource, event.getSource());
 314
 315         final String source2 = "another source";
 316         event.setSource(source2);
 317         assertEquals("setContent", source2, event.getSource());
 318
 319         event.setSource(null);
 320         assertNull("setContent", event.getSource());
 321
 322         event.setSource(fSource);
 323         assertEquals("setContent", fSource, event.getSource());
 324     }
 325
 326     public void testSetType() {
 327         final TestEvent event = new TestEvent(fEvent1);
 328         assertEquals("setType", fType, event.getType());
 329
 330         final String typeId = "OtherTestType";
 331         final String[] labels = new String[] { fLabel2, fLabel1 };
 332         final TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 333
 334         event.setType(newType);
 335         assertEquals("setType", newType, event.getType());
 336
 337         event.setType(null);
 338         assertNull("setType", event.getType());
 339
 340         event.setType(fType);
 341         assertEquals("setType", fType, event.getType());
 342     }
 343
 344     public void testSetContent() {
 345         final TestEvent event = new TestEvent(fEvent1);
 346         assertEquals("setContent", fContent1, event.getContent());
 347
 348         event.setContent(fContent2);
 349         assertEquals("setContent", fContent2, event.getContent());
 350
 351         event.setContent(null);
 352         assertNull("setContent", event.getContent());
 353
 354         event.setContent(fContent1);
 355         assertEquals("setContent", fContent1, event.getContent());
 356     }
 357
 358     public void testSetReference() {
 359         final TestEvent event = new TestEvent(fEvent1);
 360         assertEquals("setReference", fReference1, event.getReference());
 361
 362         event.setReference(fReference2);
 363         assertEquals("setReference", fReference2, event.getReference());
 364
 365         event.setReference(null);
 366         assertNull("setReference", event.getReference());
 367
 368         event.setReference(fReference1);
 369         assertEquals("setReference", fReference1, event.getReference());
 370     }
 371
 372     // ------------------------------------------------------------------------
 373     // clone
 374     // ------------------------------------------------------------------------
 375
 376     public static class MyEvent extends TmfEvent {
 377
 378         @Override
 379         public boolean equals(final Object other) {
 380             return super.equals(other);
 381         }
 382         @Override
 383         public MyEvent clone() {
 384             return (MyEvent) super.clone();
 385         }
 386     }
 387
 388     public void testClone1() throws Exception {
 389         final ITmfEvent clone = fEvent1.clone();
 390
 391         assertTrue("clone", fEvent1.clone().equals(fEvent1));
 392         assertTrue("clone", clone.clone().equals(clone));
 393
 394         assertEquals("clone", fEvent1, clone);
 395         assertEquals("clone", clone, fEvent1);
 396     }
 397
 398     public void testClone2() throws Exception {
 399         final TmfEvent event = new MyEvent();
 400         final TmfEvent clone = event.clone();
 401
 402         assertTrue("clone", event.clone().equals(event));
 403         assertTrue("clone", clone.clone().equals(clone));
 404
 405         assertEquals("clone", event, clone);
 406         assertEquals("clone", clone, event);
 407     }
 408
 409     // ------------------------------------------------------------------------
 410     // hashCode
 411     // ------------------------------------------------------------------------
 412
 413     public void testHashCode() throws Exception {
 414         TmfEvent event1 = new TmfEvent();
 415         TmfEvent event2 = new TmfEvent();
 416
 417         assertTrue("hashCode", event1.hashCode() == event2.hashCode());
 418
 419         final ITmfTrace<TmfEvent> trace = openTrace();
 420         event1 = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 421         event2 = new TmfEvent(trace, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
 422         final TmfEvent event1b = new TmfEvent(event1);
 423         final TmfEvent event2b = new TmfEvent(event2);
 424
 425         assertTrue("hashCode", event1.hashCode() == event1b.hashCode());
 426         assertTrue("hashCode", event2.hashCode() == event2b.hashCode());
 427
 428         assertTrue("hashCode", event1.hashCode() != event2.hashCode());
 429         assertTrue("hashCode", event2.hashCode() != event1.hashCode());
 430
 431         trace.dispose();
 432     }
 433
 434     // ------------------------------------------------------------------------
 435     // equals
 436     // ------------------------------------------------------------------------
 437
 438     public void testEqualsReflexivity() throws Exception {
 439         assertTrue("equals", fEvent1.equals(fEvent1));
 440         assertTrue("equals", fEvent2.equals(fEvent2));
 441
 442         assertFalse("equals", fEvent1.equals(fEvent2));
 443         assertFalse("equals", fEvent2.equals(fEvent1));
 444     }
 445
 446     public void testEqualsSymmetry() throws Exception {
 447         final TmfEvent event1 = new TmfEvent(fEvent1);
 448         final TmfEvent event2 = new TmfEvent(fEvent2);
 449
 450         assertTrue("equals", event1.equals(fEvent1));
 451         assertTrue("equals", fEvent1.equals(event1));
 452
 453         assertTrue("equals", event2.equals(fEvent2));
 454         assertTrue("equals", fEvent2.equals(event2));
 455     }
 456
 457     public void testEqualsTransivity() throws Exception {
 458         final TmfEvent event1 = new TmfEvent(fEvent1);
 459         final TmfEvent event2 = new TmfEvent(fEvent1);
 460         final TmfEvent event3 = new TmfEvent(fEvent1);
 461
 462         assertTrue("equals", event1.equals(event2));
 463         assertTrue("equals", event2.equals(event3));
 464         assertTrue("equals", event1.equals(event3));
 465     }
 466
 467     public void testEqualsNull() throws Exception {
 468         assertFalse("equals", fEvent1.equals(null));
 469         assertFalse("equals", fEvent2.equals(null));
 470     }
 471
 472     public void testNonEqualClasses() throws Exception {
 473         assertFalse("equals", fEvent1.equals(fEvent1.getType()));
 474         assertFalse("equals", fEvent1.equals(null));
 475     }
 476
 477     public void testNonEqualTraces() throws Exception {
 478         final ITmfTrace<TmfEvent> trace1 = openTrace();
 479         final ITmfTrace<TmfEvent> trace2 = openTrace();
 480
 481         final TmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 482         TmfEvent event2 = new TmfEvent(trace1,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 483         assertTrue("equals", event1.equals(event2));
 484         assertTrue("equals", event2.equals(event1));
 485
 486         event2 = new TmfEvent(null,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 487         assertFalse("equals", event1.equals(event2));
 488         assertFalse("equals", event2.equals(event1));
 489
 490         event2 = new TmfEvent(trace2,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 491         assertFalse("equals", event1.equals(event2));
 492         assertFalse("equals", event2.equals(event1));
 493
 494         trace1.dispose();
 495         trace2.dispose();
 496     }
 497
 498     public void testNonEqualRanks() throws Exception {
 499         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 500         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 501         assertTrue("equals", event1.equals(event2));
 502         assertTrue("equals", event2.equals(event1));
 503
 504         event2 = new TmfEvent(null, 1, fTimestamp1, fSource, fType, fContent1, fReference1);
 505         assertFalse("equals", event1.equals(event2));
 506         assertFalse("equals", event2.equals(event1));
 507     }
 508
 509     public void testNonEqualTimestamps() throws Exception {
 510         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 511         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 512         assertTrue("equals", event1.equals(event2));
 513         assertTrue("equals", event2.equals(event1));
 514
 515         event2 = new TmfEvent(null, 0, fTimestamp2, fSource, fType, fContent1, fReference1);
 516         assertFalse("equals", event1.equals(event2));
 517         assertFalse("equals", event2.equals(event1));
 518
 519         event2 = new TmfEvent(null, 0, null, fSource, fType, fContent1, fReference1);
 520         assertFalse("equals", event1.equals(event2));
 521         assertFalse("equals", event2.equals(event1));
 522     }
 523
 524     public void testNonEqualSources() throws Exception {
 525         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 526         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 527         assertTrue("equals", event1.equals(event2));
 528         assertTrue("equals", event2.equals(event1));
 529
 530         event2 = new TmfEvent(null, 0, fTimestamp1, fSource + "x", fType, fContent1, fReference1);
 531         assertFalse("equals", event1.equals(event2));
 532         assertFalse("equals", event2.equals(event1));
 533
 534         event2 = new TmfEvent(null, 0, fTimestamp1, null, fType, fContent1, fReference1);
 535         assertFalse("equals", event1.equals(event2));
 536         assertFalse("equals", event2.equals(event1));
 537     }
 538
 539     public void testNonEqualTypes() throws Exception {
 540         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 541         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType,  fContent1, fReference1);
 542         assertTrue("equals", event1.equals(event2));
 543         assertTrue("equals", event2.equals(event1));
 544
 545         final String typeId = "OtherTestType";
 546         final String[] labels = new String[] { fLabel2, fLabel1 };
 547         final TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 548
 549         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, newType, fContent1, fReference1);
 550         assertFalse("equals", event1.equals(event2));
 551         assertFalse("equals", event2.equals(event1));
 552
 553         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, null, fContent1, fReference1);
 554         assertFalse("equals", event1.equals(event2));
 555         assertFalse("equals", event2.equals(event1));
 556     }
 557
 558     public void testNonEqualContents() throws Exception {
 559         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 560         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 561         assertTrue("equals", event1.equals(event2));
 562         assertTrue("equals", event2.equals(event1));
 563
 564         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent2, fReference1);
 565         assertFalse("equals", event1.equals(event2));
 566         assertFalse("equals", event2.equals(event1));
 567
 568         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, null, fReference1);
 569         assertFalse("equals", event1.equals(event2));
 570         assertFalse("equals", event2.equals(event1));
 571     }
 572
 573     public void testNonEqualReferences() throws Exception {
 574         final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 575         TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 576         assertTrue("equals", event1.equals(event2));
 577         assertTrue("equals", event2.equals(event1));
 578
 579         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference2);
 580         assertFalse("equals", event1.equals(event2));
 581         assertFalse("equals", event2.equals(event1));
 582
 583         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, null);
 584         assertFalse("equals", event1.equals(event2));
 585         assertFalse("equals", event2.equals(event1));
 586     }
 587
 588     // ------------------------------------------------------------------------
 589     // toString
 590     // ------------------------------------------------------------------------
 591
 592     public void testToString() {
 593         final String expected1 = "TmfEvent [fTimestamp=" + fTimestamp1 + ", fTrace=null, fRank=0, fSource=" + fSource
 594                 + ", fType=" + fType + ", fContent=" + fContent1 + ", fReference=" + fReference1 + "]";
 595         assertEquals("toString", expected1, fEvent1.toString());
 596
 597         final String expected2 = "TmfEvent [fTimestamp=" + fTimestamp2 + ", fTrace=null, fRank=1, fSource=" + fSource
 598                 + ", fType=" + fType + ", fContent=" + fContent2 + ", fReference=" + fReference2 + "]";
 599         assertEquals("toString", expected2, fEvent2.toString());
 600     }
 601
 602 }