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 ITmfEvent 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 ITmfEvent 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 ITmfEvent 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     // hashCode
 413     // ------------------------------------------------------------------------
 414
 415     /**
 416      *
 417      */
 418     public void testHashCode() {
 419         ITmfEvent event1 = new TmfEvent();
 420         ITmfEvent event2 = new TmfEvent();
 421
 422         assertTrue("hashCode", event1.hashCode() == event2.hashCode());
 423
 424         final ITmfTrace trace = openTrace();
 425         event1 = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 426         event2 = new TmfEvent(trace, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
 427         final ITmfEvent event1b = new TmfEvent(event1);
 428         final ITmfEvent event2b = new TmfEvent(event2);
 429
 430         assertTrue("hashCode", event1.hashCode() == event1b.hashCode());
 431         assertTrue("hashCode", event2.hashCode() == event2b.hashCode());
 432
 433         assertTrue("hashCode", event1.hashCode() != event2.hashCode());
 434         assertTrue("hashCode", event2.hashCode() != event1.hashCode());
 435
 436         trace.dispose();
 437     }
 438
 439     // ------------------------------------------------------------------------
 440     // equals
 441     // ------------------------------------------------------------------------
 442
 443     /**
 444      *
 445      */
 446     public void testEqualsReflexivity() {
 447         assertTrue("equals", fEvent1.equals(fEvent1));
 448         assertTrue("equals", fEvent2.equals(fEvent2));
 449
 450         assertFalse("equals", fEvent1.equals(fEvent2));
 451         assertFalse("equals", fEvent2.equals(fEvent1));
 452     }
 453
 454     /**
 455      *
 456      */
 457     public void testEqualsSymmetry() {
 458         final ITmfEvent event1 = new TmfEvent(fEvent1);
 459         final ITmfEvent event2 = new TmfEvent(fEvent2);
 460
 461         assertTrue("equals", event1.equals(fEvent1));
 462         assertTrue("equals", fEvent1.equals(event1));
 463
 464         assertTrue("equals", event2.equals(fEvent2));
 465         assertTrue("equals", fEvent2.equals(event2));
 466     }
 467
 468     /**
 469      *
 470      */
 471     public void testEqualsTransivity() {
 472         final ITmfEvent event1 = new TmfEvent(fEvent1);
 473         final ITmfEvent event2 = new TmfEvent(fEvent1);
 474         final ITmfEvent event3 = new TmfEvent(fEvent1);
 475
 476         assertTrue("equals", event1.equals(event2));
 477         assertTrue("equals", event2.equals(event3));
 478         assertTrue("equals", event1.equals(event3));
 479     }
 480
 481     /**
 482      *
 483      */
 484     public void testEqualsNull() {
 485         assertFalse("equals", fEvent1.equals(null));
 486         assertFalse("equals", fEvent2.equals(null));
 487     }
 488
 489     /**
 490      *
 491      */
 492     public void testNonEqualClasses() {
 493         assertFalse("equals", fEvent1.equals(fEvent1.getType()));
 494         assertFalse("equals", fEvent1.equals(null));
 495     }
 496
 497     /**
 498      *
 499      */
 500     public void testNonEqualTraces() {
 501         final ITmfTrace trace1 = openTrace();
 502         final ITmfTrace trace2 = openTrace();
 503
 504         final ITmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 505         ITmfEvent event2 = new TmfEvent(trace1,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 506         assertTrue("equals", event1.equals(event2));
 507         assertTrue("equals", event2.equals(event1));
 508
 509         event2 = new TmfEvent(null,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 510         assertFalse("equals", event1.equals(event2));
 511         assertFalse("equals", event2.equals(event1));
 512
 513         event2 = new TmfEvent(trace2,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
 514         assertFalse("equals", event1.equals(event2));
 515         assertFalse("equals", event2.equals(event1));
 516
 517         trace1.dispose();
 518         trace2.dispose();
 519     }
 520
 521     /**
 522      *
 523      */
 524     public void testNonEqualRanks() {
 525         final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 526         ITmfEvent 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, 1, fTimestamp1, fSource, fType, fContent1, fReference1);
 531         assertFalse("equals", event1.equals(event2));
 532         assertFalse("equals", event2.equals(event1));
 533     }
 534
 535     /**
 536      *
 537      */
 538     public void testNonEqualTimestamps() {
 539         final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 540         ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 541         assertTrue("equals", event1.equals(event2));
 542         assertTrue("equals", event2.equals(event1));
 543
 544         event2 = new TmfEvent(null, 0, fTimestamp2, fSource, fType, fContent1, fReference1);
 545         assertFalse("equals", event1.equals(event2));
 546         assertFalse("equals", event2.equals(event1));
 547
 548         event2 = new TmfEvent(null, 0, null, fSource, fType, fContent1, fReference1);
 549         assertFalse("equals", event1.equals(event2));
 550         assertFalse("equals", event2.equals(event1));
 551     }
 552
 553     /**
 554      *
 555      */
 556     public void testNonEqualSources() {
 557         final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 558         ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 559         assertTrue("equals", event1.equals(event2));
 560         assertTrue("equals", event2.equals(event1));
 561
 562         event2 = new TmfEvent(null, 0, fTimestamp1, fSource + "x", fType, fContent1, fReference1);
 563         assertFalse("equals", event1.equals(event2));
 564         assertFalse("equals", event2.equals(event1));
 565
 566         event2 = new TmfEvent(null, 0, fTimestamp1, null, fType, fContent1, fReference1);
 567         assertFalse("equals", event1.equals(event2));
 568         assertFalse("equals", event2.equals(event1));
 569     }
 570
 571     /**
 572      *
 573      */
 574     public void testNonEqualTypes() {
 575         final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 576         ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType,  fContent1, fReference1);
 577         assertTrue("equals", event1.equals(event2));
 578         assertTrue("equals", event2.equals(event1));
 579
 580         final String typeId = "OtherTestType";
 581         final String[] labels = new String[] { fLabel2, fLabel1 };
 582         final TmfEventType newType = new TmfEventType(fContext, typeId, TmfEventField.makeRoot(labels));
 583
 584         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, newType, fContent1, fReference1);
 585         assertFalse("equals", event1.equals(event2));
 586         assertFalse("equals", event2.equals(event1));
 587
 588         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, null, fContent1, fReference1);
 589         assertFalse("equals", event1.equals(event2));
 590         assertFalse("equals", event2.equals(event1));
 591     }
 592
 593     /**
 594      *
 595      */
 596     public void testNonEqualContents() {
 597         final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 598         ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 599         assertTrue("equals", event1.equals(event2));
 600         assertTrue("equals", event2.equals(event1));
 601
 602         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent2, fReference1);
 603         assertFalse("equals", event1.equals(event2));
 604         assertFalse("equals", event2.equals(event1));
 605
 606         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, null, fReference1);
 607         assertFalse("equals", event1.equals(event2));
 608         assertFalse("equals", event2.equals(event1));
 609     }
 610
 611     /**
 612      *
 613      */
 614     public void testNonEqualReferences() {
 615         final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 616         ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 617         assertTrue("equals", event1.equals(event2));
 618         assertTrue("equals", event2.equals(event1));
 619
 620         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference2);
 621         assertFalse("equals", event1.equals(event2));
 622         assertFalse("equals", event2.equals(event1));
 623
 624         event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, null);
 625         assertFalse("equals", event1.equals(event2));
 626         assertFalse("equals", event2.equals(event1));
 627     }
 628
 629     // ------------------------------------------------------------------------
 630     // toString
 631     // ------------------------------------------------------------------------
 632
 633     /**
 634      *
 635      */
 636     public void testToString() {
 637         final String expected1 = "TmfEvent [fTimestamp=" + fTimestamp1 + ", fTrace=null, fRank=0, fSource=" + fSource
 638                 + ", fType=" + fType + ", fContent=" + fContent1 + ", fReference=" + fReference1 + "]";
 639         assertEquals("toString", expected1, fEvent1.toString());
 640
 641         final String expected2 = "TmfEvent [fTimestamp=" + fTimestamp2 + ", fTrace=null, fRank=1, fSource=" + fSource
 642                 + ", fType=" + fType + ", fContent=" + fContent2 + ", fReference=" + fReference2 + "]";
 643         assertEquals("toString", expected2, fEvent2.toString());
 644     }
 645
 646 }