← Back to branch summary

~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

« 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/TmfEventTypeTest.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2012-06-29 12:07:30 UTC
  • Revision ID: package-import@ubuntu.com-20120629120730-bfri1xys1i71dpn6
Tags: upstream-1.0.0
Import upstream version 1.0.0

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/TmfEventTypeTest.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 2009, 2012 Ericsson
 
3
 * 
 
4
 * All rights reserved. This program and the accompanying materials are made
 
5
 * 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 junit.framework.TestCase;
 
17
 
 
18
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
 
19
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
 
20
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
 
21
 
 
22
/**
 
23
 * Test suite for the TmfEventType class.
 
24
 */
 
25
@SuppressWarnings("nls")
 
26
public class TmfEventTypeTest extends TestCase {
 
27
 
 
28
    // ------------------------------------------------------------------------
 
29
    // Variables
 
30
    // ------------------------------------------------------------------------
 
31
 
 
32
    private final String fContext1 = "JUnit context 1";
 
33
    private final String fContext2 = "JUnit context 2";
 
34
 
 
35
    private final String fTypeId1 = "Some type";
 
36
    private final String fTypeId2 = "Some other type";
 
37
 
 
38
    private final String fLabel0 = "label1";
 
39
    private final String fLabel1 = "label2";
 
40
 
 
41
    private final String[] fLabels0 = new String[] { };
 
42
    private final String[] fLabels1 = new String[] { fLabel0, fLabel1 };
 
43
    private final String[] fLabels2 = new String[] { fLabel1, fLabel0, fLabel1 };
 
44
 
 
45
    private final ITmfEventType fType0 = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels0));
 
46
    private final ITmfEventType fType1 = new TmfEventType(fContext1, fTypeId2, TmfEventField.makeRoot(fLabels1));
 
47
    private final ITmfEventType fType2 = new TmfEventType(fContext2, fTypeId1, TmfEventField.makeRoot(fLabels2));
 
48
    private final ITmfEventType fType3 = new TmfEventType(fContext2, fTypeId2, TmfEventField.makeRoot(fLabels1));
 
49
 
 
50
    // ------------------------------------------------------------------------
 
51
    // Housekeeping
 
52
    // ------------------------------------------------------------------------
 
53
 
 
54
    /**
 
55
     * @param name the test name
 
56
     */
 
57
    public TmfEventTypeTest(final String name) {
 
58
        super(name);
 
59
    }
 
60
 
 
61
    @Override
 
62
    protected void setUp() throws Exception {
 
63
        super.setUp();
 
64
    }
 
65
 
 
66
    @Override
 
67
    protected void tearDown() throws Exception {
 
68
        super.tearDown();
 
69
    }
 
70
 
 
71
    // ------------------------------------------------------------------------
 
72
    // Constructors
 
73
    // ------------------------------------------------------------------------
 
74
 
 
75
    public void testDefaultConstructor() {
 
76
        final ITmfEventType type = new TmfEventType();
 
77
        assertEquals("getContext", TmfEventType.DEFAULT_CONTEXT_ID, type.getContext());
 
78
        assertEquals("getName", TmfEventType.DEFAULT_TYPE_ID, type.getName());
 
79
        assertNull("getRootField", type.getRootField());
 
80
        assertEquals("getFieldNames", 0, type.getFieldNames().length);
 
81
        assertNull("getFieldName", type.getFieldName(0));
 
82
    }
 
83
 
 
84
    public void testFullConstructor() {
 
85
        final ITmfEventType type0 = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels0));
 
86
        assertEquals("getContext", fContext1, type0.getContext());
 
87
        assertEquals("getName", fTypeId1, type0.getName());
 
88
        assertEquals("getRootField", TmfEventField.makeRoot(fLabels0), type0.getRootField());
 
89
        final String[] labels0 = type0.getFieldNames();
 
90
        assertEquals("getFieldNames length", fLabels0.length, labels0.length);
 
91
        for (int i = 0; i < labels0.length; i++)
 
92
            assertEquals("getFieldNames", fLabels0[i], labels0[i]);
 
93
        assertNull("getFieldName", type0.getFieldName(labels0.length));
 
94
 
 
95
        final ITmfEventType type1 = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels1));
 
96
        assertEquals("getContext", fContext1, type1.getContext());
 
97
        assertEquals("getName", fTypeId1, type1.getName());
 
98
        assertEquals("getRootField", TmfEventField.makeRoot(fLabels1), type1.getRootField());
 
99
        final String[] labels1 = type1.getFieldNames();
 
100
        assertEquals("getFieldNames length", fLabels1.length, labels1.length);
 
101
        for (int i = 0; i < labels1.length; i++)
 
102
            assertEquals("getFieldNames", fLabels1[i], labels1[i]);
 
103
        assertNull("getFieldName", type1.getFieldName(labels1.length));
 
104
 
 
105
        final ITmfEventType type2 = new TmfEventType(fContext2, fTypeId2, TmfEventField.makeRoot(fLabels2));
 
106
        assertEquals("getContext", fContext2, type2.getContext());
 
107
        assertEquals("getName", fTypeId2, type2.getName());
 
108
        assertEquals("getRootField", TmfEventField.makeRoot(fLabels2), type2.getRootField());
 
109
        final String[] labels2 = type2.getFieldNames();
 
110
        assertEquals("getFieldNames length", fLabels2.length, labels2.length);
 
111
        for (int i = 0; i < labels2.length; i++)
 
112
            assertEquals("getFieldNames", fLabels2[i], labels2[i]);
 
113
        assertNull("getFieldName", type2.getFieldName(labels2.length));
 
114
    }
 
115
 
 
116
    public void testConstructorCornerCases() {
 
117
        try {
 
118
            new TmfEventType(null, fTypeId1, null);
 
119
            fail("TmfEventType: null context");
 
120
        } catch (final IllegalArgumentException e) {
 
121
        }
 
122
 
 
123
        try {
 
124
            new TmfEventType(fContext1, null, null);
 
125
            fail("TmfEventType: null type");
 
126
        } catch (final IllegalArgumentException e) {
 
127
        }
 
128
    }
 
129
 
 
130
    public void testCopyConstructor() {
 
131
        final TmfEventType original = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels1));
 
132
        final TmfEventType copy = new TmfEventType(original);
 
133
 
 
134
        assertEquals("getContext", fContext1, copy.getContext());
 
135
        assertEquals("getName", fTypeId1, copy.getName());
 
136
        assertEquals("getRootField", TmfEventField.makeRoot(fLabels1), copy.getRootField());
 
137
        final String[] labels1 = copy.getFieldNames();
 
138
        assertEquals("getFieldNames length", fLabels1.length, labels1.length);
 
139
        for (int i = 0; i < labels1.length; i++)
 
140
            assertEquals("getFieldNames", fLabels1[i], labels1[i]);
 
141
        assertNull("getFieldName", copy.getFieldName(labels1.length));
 
142
    }
 
143
 
 
144
    public void testCopyConstructorCornerCases() {
 
145
        try {
 
146
            new TmfEventType(null);
 
147
            fail("TmfEventType: null argument");
 
148
        } catch (final IllegalArgumentException e) {
 
149
        }
 
150
    }
 
151
 
 
152
    // ------------------------------------------------------------------------
 
153
    // clone
 
154
    // ------------------------------------------------------------------------
 
155
 
 
156
    public static class MyEventType extends TmfEventType {
 
157
 
 
158
        @Override
 
159
        public boolean equals(final Object other) {
 
160
            return super.equals(other);
 
161
        }
 
162
 
 
163
        @Override
 
164
        public MyEventType clone() {
 
165
            return (MyEventType) super.clone();
 
166
        }
 
167
    }
 
168
 
 
169
    public void testClone() throws Exception {
 
170
        final ITmfEventType clone = fType1.clone();
 
171
 
 
172
        assertTrue("clone", fType1.clone().equals(fType1));
 
173
        assertTrue("clone", clone.clone().equals(clone));
 
174
 
 
175
        assertEquals("clone", clone, fType1);
 
176
        assertEquals("clone", fType1, clone);
 
177
    }
 
178
 
 
179
    public void testClone2() throws Exception {
 
180
        final ITmfEventType type = new TmfEventType();
 
181
        final ITmfEventType clone = type.clone();
 
182
 
 
183
        assertTrue("clone", type.clone().equals(type));
 
184
        assertTrue("clone", clone.clone().equals(clone));
 
185
 
 
186
        assertEquals("clone", clone, type);
 
187
        assertEquals("clone", type, clone);
 
188
    }
 
189
 
 
190
    // ------------------------------------------------------------------------
 
191
    // hashCode
 
192
    // ------------------------------------------------------------------------
 
193
 
 
194
    public void testHashCode() throws Exception {
 
195
        final TmfEventType copy1 = new TmfEventType(fType0);
 
196
 
 
197
        assertTrue("hashCode", fType0.hashCode() == copy1.hashCode());
 
198
        assertTrue("hashCode", fType0.hashCode() != fType3.hashCode());
 
199
    }
 
200
 
 
201
    // ------------------------------------------------------------------------
 
202
    // equals
 
203
    // ------------------------------------------------------------------------
 
204
 
 
205
    public void testEqualsReflexivity() throws Exception {
 
206
        assertTrue("equals", fType0.equals(fType0));
 
207
        assertTrue("equals", fType3.equals(fType3));
 
208
 
 
209
        assertFalse("equals", fType0.equals(fType3));
 
210
        assertFalse("equals", fType3.equals(fType0));
 
211
    }
 
212
 
 
213
    public void testEqualsSymmetry() throws Exception {
 
214
        final TmfEventType copy0 = new TmfEventType(fType0);
 
215
        assertTrue("equals", fType0.equals(copy0));
 
216
        assertTrue("equals", copy0.equals(fType0));
 
217
 
 
218
        final TmfEventType copy1 = new TmfEventType(fType1);
 
219
        assertTrue("equals", fType1.equals(copy1));
 
220
        assertTrue("equals", copy1.equals(fType1));
 
221
 
 
222
        final TmfEventType copy2 = new TmfEventType(fType2);
 
223
        assertTrue("equals", fType2.equals(copy2));
 
224
        assertTrue("equals", copy2.equals(fType2));
 
225
    }
 
226
 
 
227
    public void testEqualsTransivity() throws Exception {
 
228
        TmfEventType copy1 = new TmfEventType(fType1);
 
229
        TmfEventType copy2 = new TmfEventType(copy1);
 
230
        assertTrue("equals", fType1.equals(copy1));
 
231
        assertTrue("equals", copy1.equals(copy2));
 
232
        assertTrue("equals", fType1.equals(copy2));
 
233
 
 
234
        copy1 = new TmfEventType(fType2);
 
235
        copy2 = new TmfEventType(copy1);
 
236
        assertTrue("equals", fType2.equals(copy1));
 
237
        assertTrue("equals", copy1.equals(copy2));
 
238
        assertTrue("equals", fType2.equals(copy2));
 
239
 
 
240
        copy1 = new TmfEventType(fType3);
 
241
        copy2 = new TmfEventType(copy1);
 
242
        assertTrue("equals", fType3.equals(copy1));
 
243
        assertTrue("equals", copy1.equals(copy2));
 
244
        assertTrue("equals", fType3.equals(copy2));
 
245
    }
 
246
 
 
247
    public void testEqualsNull() throws Exception {
 
248
        assertFalse("equals", fType0.equals(null));
 
249
        assertFalse("equals", fType3.equals(null));
 
250
    }
 
251
 
 
252
    public void testNonEquals() throws Exception {
 
253
        assertFalse("equals", fType0.equals(fType1));
 
254
        assertFalse("equals", fType1.equals(fType2));
 
255
        assertFalse("equals", fType2.equals(fType3));
 
256
        assertFalse("equals", fType3.equals(fType0));
 
257
    }
 
258
 
 
259
    public void testNonEqualsClasses() throws Exception {
 
260
        assertFalse("equals", fType1.equals(fLabels1));
 
261
    }
 
262
 
 
263
    // ------------------------------------------------------------------------
 
264
    // toString
 
265
    // ------------------------------------------------------------------------
 
266
 
 
267
    public void testToString() {
 
268
        final String expected1 = "TmfEventType [fContext=" + TmfEventType.DEFAULT_CONTEXT_ID +
 
269
                ", fTypeId=" + TmfEventType.DEFAULT_TYPE_ID + "]";
 
270
        final TmfEventType type1 = new TmfEventType();
 
271
        assertEquals("toString", expected1, type1.toString());
 
272
 
 
273
        final String expected2 = "TmfEventType [fContext=" + fContext1 + ", fTypeId=" + fTypeId1 + "]";
 
274
        final TmfEventType type2 = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels1));
 
275
        assertEquals("toString", expected2, type2.toString());
 
276
    }
 
277
 
 
278
}