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