← Back to branch summary

~ubuntu-branches/ubuntu/utopic/eclipse-linuxtools/utopic

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/event/TmfEventTest.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2014-05-12 18:11:40 UTC
  • mfrom: (3.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140512181140-w237r3vsah1tmybz
Tags: 2.2.1-1
* New upstream release.
* Refreshed d/patches.
* Removed eclipse-cdt-valgrind-remote package, all its functionality
  is now provided by eclipse-cdt-profiling-framework-remote.
* Added remove-license-feature.patch.
* Bump Standards-Version to 3.9.5.
* Enable eclipse-changelog package.
* Enable eclipse-rpm-editor package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lttng/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/event/TmfEventTest.java
1
1
/*******************************************************************************
2
 
 * Copyright (c) 2009, 2012 Ericsson
 
2
 * Copyright (c) 2009, 2013 Ericsson
3
3
 *
4
4
 * All rights reserved. This program and the accompanying materials are
5
5
 * made available under the terms of the Eclipse Public License v1.0 which
9
9
 * Contributors:
10
10
 *   Francois Chouinard - Initial API and implementation
11
11
 *   Francois Chouinard - Adjusted for new Event Model
 
12
 *   Alexandre Montplaisir - Port to JUnit4
12
13
 *******************************************************************************/
13
14
 
14
15
package org.eclipse.linuxtools.tmf.core.tests.event;
15
16
 
 
17
import static org.junit.Assert.assertEquals;
 
18
import static org.junit.Assert.assertFalse;
 
19
import static org.junit.Assert.assertNotNull;
 
20
import static org.junit.Assert.assertNull;
 
21
import static org.junit.Assert.assertTrue;
 
22
import static org.junit.Assert.fail;
 
23
 
16
24
import java.io.File;
17
25
import java.io.IOException;
18
26
import java.net.URISyntaxException;
19
27
import java.net.URL;
20
28
 
21
 
import junit.framework.TestCase;
22
 
 
23
29
import org.eclipse.core.runtime.FileLocator;
24
30
import org.eclipse.core.runtime.Path;
25
31
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
26
32
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
27
33
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
28
 
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
29
34
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
30
35
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
31
36
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
32
 
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
33
37
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
34
38
import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
 
39
import org.eclipse.linuxtools.tmf.core.tests.shared.TmfTestTrace;
 
40
import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
35
41
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
36
42
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
37
43
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
 
44
import org.junit.Test;
38
45
 
39
46
/**
40
47
 * Test suite for the TmfEvent class.
41
48
 */
42
 
@SuppressWarnings("nls")
43
 
public class TmfEventTest extends TestCase {
 
49
@SuppressWarnings("javadoc")
 
50
public class TmfEventTest {
44
51
 
45
52
    // ------------------------------------------------------------------------
46
53
    // Variables
57
64
 
58
65
    private final Object fValue1a = "Some string";
59
66
    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);
 
67
    private final ITmfEventField fField1a = new TmfEventField(fLabel1, fValue1a, null);
 
68
    private final ITmfEventField fField1b = new TmfEventField(fLabel2, fValue1b, null);
62
69
    private final ITmfEventField[] fFields1 = new ITmfEventField[] { fField1a, fField1b };
63
70
    private final String fRawContent1 = fField1a.toString() + fField1b.toString();
64
 
    private final ITmfEventField fContent1 = new TmfEventField(fRawContent1, fFields1);
 
71
    private final ITmfEventField fContent1 = new TmfEventField(fRawContent1, null, fFields1);
65
72
    private final TmfTimestamp fTimestamp1 = new TmfTimestamp(12345, 2, 5);
66
73
    private final String fReference1 = "Some reference";
67
74
    private final ITmfEvent fEvent1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
68
75
 
69
76
    private final Object fValue2a = "Another string";
70
77
    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);
 
78
    private final ITmfEventField fField2a = new TmfEventField(fLabel1, fValue2a, null);
 
79
    private final ITmfEventField fField2b = new TmfEventField(fLabel2, fValue2b, null);
73
80
    private final ITmfEventField[] fFields2 = new ITmfEventField[] { fField2a, fField2b };
74
81
    private final String fRawContent2 = fField2a.toString() + fField2b.toString();
75
 
    private final ITmfEventField fContent2 = new TmfEventField(fRawContent2, fFields2);
 
82
    private final ITmfEventField fContent2 = new TmfEventField(fRawContent2, null, fFields2);
76
83
    private final TmfTimestamp fTimestamp2 = new TmfTimestamp(12350, 2, 5);
77
84
    private final String fReference2 = "Some other reference";
78
85
    private final ITmfEvent fEvent2 = new TmfEvent(null, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
79
86
 
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
87
    // ------------------------------------------------------------------------
104
88
    // Helper functions
105
89
    // ------------------------------------------------------------------------
106
90
 
107
91
    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
92
        TmfTraceStub trace = null;
113
93
        try {
114
 
            final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
 
94
            final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TmfTestTrace.A_TEST_10K.getFullPath()), null);
115
95
            final File test = new File(FileLocator.toFileURL(location).toURI());
116
96
            trace = new TmfTraceStub(test.toURI().getPath(), 500, false);
117
97
        } catch (final TmfTraceException e) {
128
108
    // Constructors
129
109
    // ------------------------------------------------------------------------
130
110
 
131
 
    /**
132
 
     *
133
 
     */
 
111
    @Test
134
112
    public void testDefaultConstructor() {
135
113
        final ITmfEvent event = new TmfEvent();
136
114
        assertNull("getTrace", event.getTrace());
142
120
        assertNull("getReference", event.getReference());
143
121
    }
144
122
 
145
 
    /**
146
 
     *
147
 
     */
 
123
    @Test
148
124
    public void testFullConstructor() {
149
125
        assertNull("getTrace", fEvent1.getTrace());
150
126
        assertEquals("getRank", 0, fEvent1.getRank());
163
139
        assertEquals("getReference", fReference2, fEvent2.getReference());
164
140
    }
165
141
 
166
 
    /**
167
 
     *
168
 
     */
 
142
    @Test
169
143
    public void testNoRankConstructor() {
170
 
        final TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
 
144
        final ITmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
171
145
        assertNull("getTrace", event.getTrace());
172
146
        assertEquals("getRank", ITmfContext.UNKNOWN_RANK, event.getRank());
173
147
        assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
177
151
        assertEquals("getReference", fReference1, event.getReference());
178
152
    }
179
153
 
180
 
    /**
181
 
     *
182
 
     */
 
154
    @Test
183
155
    public void testConstructorWithTrace() {
184
 
        final ITmfTrace<TmfEvent> trace = openTrace();
185
 
        final TmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
156
        final ITmfTrace trace = openTrace();
 
157
        final ITmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
186
158
        assertNotNull("getTrace", event.getTrace());
187
159
        assertEquals("getRank", 0, event.getRank());
188
160
        assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
193
165
        trace.dispose();
194
166
    }
195
167
 
196
 
    /**
197
 
     *
198
 
     */
 
168
    @Test
199
169
    public void testTmfEventCopy() {
200
 
        final TmfEvent event = new TmfEvent(fEvent1);
 
170
        final ITmfEvent event = new TmfEvent(fEvent1);
201
171
        assertNull("getTrace", event.getTrace());
202
172
        assertEquals("getRank", 0, event.getRank());
203
173
        assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
207
177
        assertEquals("getReference", fReference1, event.getReference());
208
178
    }
209
179
 
210
 
    /**
211
 
     *
212
 
     */
 
180
    @Test
213
181
    public void testEventCopy2() {
214
182
        try {
215
183
            new TmfEvent(null);
220
188
    }
221
189
 
222
190
    // ------------------------------------------------------------------------
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<? extends ITmfEvent> 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<TmfEvent> setupTrace() {
270
 
        ITmfTrace<TmfEvent> 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<TmfEvent> 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
191
    // hashCode
456
192
    // ------------------------------------------------------------------------
457
193
 
458
 
    /**
459
 
     *
460
 
     */
 
194
    @Test
461
195
    public void testHashCode() {
462
 
        TmfEvent event1 = new TmfEvent();
463
 
        TmfEvent event2 = new TmfEvent();
 
196
        ITmfEvent event1 = new TmfEvent();
 
197
        ITmfEvent event2 = new TmfEvent();
464
198
 
465
199
        assertTrue("hashCode", event1.hashCode() == event2.hashCode());
466
200
 
467
 
        final ITmfTrace<TmfEvent> trace = openTrace();
 
201
        final ITmfTrace trace = openTrace();
468
202
        event1 = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
469
203
        event2 = new TmfEvent(trace, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
470
 
        final TmfEvent event1b = new TmfEvent(event1);
471
 
        final TmfEvent event2b = new TmfEvent(event2);
 
204
        final ITmfEvent event1b = new TmfEvent(event1);
 
205
        final ITmfEvent event2b = new TmfEvent(event2);
472
206
 
473
207
        assertTrue("hashCode", event1.hashCode() == event1b.hashCode());
474
208
        assertTrue("hashCode", event2.hashCode() == event2b.hashCode());
483
217
    // equals
484
218
    // ------------------------------------------------------------------------
485
219
 
486
 
    /**
487
 
     *
488
 
     */
 
220
    @Test
489
221
    public void testEqualsReflexivity() {
490
222
        assertTrue("equals", fEvent1.equals(fEvent1));
491
223
        assertTrue("equals", fEvent2.equals(fEvent2));
494
226
        assertFalse("equals", fEvent2.equals(fEvent1));
495
227
    }
496
228
 
497
 
    /**
498
 
     *
499
 
     */
 
229
    @Test
500
230
    public void testEqualsSymmetry() {
501
 
        final TmfEvent event1 = new TmfEvent(fEvent1);
502
 
        final TmfEvent event2 = new TmfEvent(fEvent2);
 
231
        final ITmfEvent event1 = new TmfEvent(fEvent1);
 
232
        final ITmfEvent event2 = new TmfEvent(fEvent2);
503
233
 
504
234
        assertTrue("equals", event1.equals(fEvent1));
505
235
        assertTrue("equals", fEvent1.equals(event1));
508
238
        assertTrue("equals", fEvent2.equals(event2));
509
239
    }
510
240
 
511
 
    /**
512
 
     *
513
 
     */
 
241
    @Test
514
242
    public void testEqualsTransivity() {
515
 
        final TmfEvent event1 = new TmfEvent(fEvent1);
516
 
        final TmfEvent event2 = new TmfEvent(fEvent1);
517
 
        final TmfEvent event3 = new TmfEvent(fEvent1);
 
243
        final ITmfEvent event1 = new TmfEvent(fEvent1);
 
244
        final ITmfEvent event2 = new TmfEvent(fEvent1);
 
245
        final ITmfEvent event3 = new TmfEvent(fEvent1);
518
246
 
519
247
        assertTrue("equals", event1.equals(event2));
520
248
        assertTrue("equals", event2.equals(event3));
521
249
        assertTrue("equals", event1.equals(event3));
522
250
    }
523
251
 
524
 
    /**
525
 
     *
526
 
     */
 
252
    @Test
527
253
    public void testEqualsNull() {
528
254
        assertFalse("equals", fEvent1.equals(null));
529
255
        assertFalse("equals", fEvent2.equals(null));
530
256
    }
531
257
 
532
 
    /**
533
 
     *
534
 
     */
 
258
    @Test
535
259
    public void testNonEqualClasses() {
536
260
        assertFalse("equals", fEvent1.equals(fEvent1.getType()));
537
261
        assertFalse("equals", fEvent1.equals(null));
538
262
    }
539
263
 
540
 
    /**
541
 
     *
542
 
     */
 
264
    @Test
543
265
    public void testNonEqualTraces() {
544
 
        final ITmfTrace<TmfEvent> trace1 = openTrace();
545
 
        final ITmfTrace<TmfEvent> trace2 = openTrace();
 
266
        final ITmfTrace trace1 = openTrace();
 
267
        final ITmfTrace trace2 = openTrace();
546
268
 
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);
 
269
        final ITmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
270
        ITmfEvent event2 = new TmfEvent(trace1,  0, fTimestamp1, fSource, fType, fContent1, fReference1);
549
271
        assertTrue("equals", event1.equals(event2));
550
272
        assertTrue("equals", event2.equals(event1));
551
273
 
561
283
        trace2.dispose();
562
284
    }
563
285
 
564
 
    /**
565
 
     *
566
 
     */
 
286
    @Test
567
287
    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);
 
288
        final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
289
        ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
570
290
        assertTrue("equals", event1.equals(event2));
571
291
        assertTrue("equals", event2.equals(event1));
572
292
 
575
295
        assertFalse("equals", event2.equals(event1));
576
296
    }
577
297
 
578
 
    /**
579
 
     *
580
 
     */
 
298
    @Test
581
299
    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);
 
300
        final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
301
        ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
584
302
        assertTrue("equals", event1.equals(event2));
585
303
        assertTrue("equals", event2.equals(event1));
586
304
 
593
311
        assertFalse("equals", event2.equals(event1));
594
312
    }
595
313
 
596
 
    /**
597
 
     *
598
 
     */
 
314
    @Test
599
315
    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);
 
316
        final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
317
        ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
602
318
        assertTrue("equals", event1.equals(event2));
603
319
        assertTrue("equals", event2.equals(event1));
604
320
 
611
327
        assertFalse("equals", event2.equals(event1));
612
328
    }
613
329
 
614
 
    /**
615
 
     *
616
 
     */
 
330
    @Test
617
331
    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);
 
332
        final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
333
        ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType,  fContent1, fReference1);
620
334
        assertTrue("equals", event1.equals(event2));
621
335
        assertTrue("equals", event2.equals(event1));
622
336
 
633
347
        assertFalse("equals", event2.equals(event1));
634
348
    }
635
349
 
636
 
    /**
637
 
     *
638
 
     */
 
350
    @Test
639
351
    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);
 
352
        final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
353
        ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
642
354
        assertTrue("equals", event1.equals(event2));
643
355
        assertTrue("equals", event2.equals(event1));
644
356
 
651
363
        assertFalse("equals", event2.equals(event1));
652
364
    }
653
365
 
654
 
    /**
655
 
     *
656
 
     */
 
366
    @Test
657
367
    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);
 
368
        final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
 
369
        ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
660
370
        assertTrue("equals", event1.equals(event2));
661
371
        assertTrue("equals", event2.equals(event1));
662
372
 
673
383
    // toString
674
384
    // ------------------------------------------------------------------------
675
385
 
676
 
    /**
677
 
     *
678
 
     */
 
386
    @Test
679
387
    public void testToString() {
680
388
        final String expected1 = "TmfEvent [fTimestamp=" + fTimestamp1 + ", fTrace=null, fRank=0, fSource=" + fSource
681
389
                + ", fType=" + fType + ", fContent=" + fContent1 + ", fReference=" + fReference1 + "]";
686
394
        assertEquals("toString", expected2, fEvent2.toString());
687
395
    }
688
396
 
 
397
    /**
 
398
     * Test the .toString() with extended classes.
 
399
     * It should print the correct class name.
 
400
     */
 
401
    @Test
 
402
    public void testToStringExtended() {
 
403
        class ExtendedEvent extends TmfEvent {
 
404
            ExtendedEvent(ITmfEvent event) {
 
405
                super(event);
 
406
            }
 
407
        }
 
408
        ExtendedEvent event = new ExtendedEvent(fEvent1);
 
409
        String expected = "ExtendedEvent [fTimestamp=" + fTimestamp1
 
410
                + ", fTrace=null, fRank=0, fSource=" + fSource
 
411
                + ", fType=" + fType + ", fContent=" + fContent1
 
412
                + ", fReference=" + fReference1 + "]";
 
413
 
 
414
        assertEquals(expected, event.toString());
 
415
    }
 
416
 
689
417
}