← 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/TmfEventTypeManagerTest.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/TmfEventTypeManagerTest.java
 
1
/*******************************************************************************
 
2
 * Copyright (c) 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
 *******************************************************************************/
 
12
 
 
13
package org.eclipse.linuxtools.tmf.core.tests.event;
 
14
 
 
15
import java.util.Arrays;
 
16
 
 
17
import junit.framework.TestCase;
 
18
 
 
19
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
 
20
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
 
21
import org.eclipse.linuxtools.tmf.core.event.TmfEventType;
 
22
import org.eclipse.linuxtools.tmf.core.event.TmfEventTypeManager;
 
23
 
 
24
/**
 
25
 * Test suite for the TmfEventTypeManager class.
 
26
 */
 
27
@SuppressWarnings("nls")
 
28
public class TmfEventTypeManagerTest extends TestCase {
 
29
 
 
30
    // ------------------------------------------------------------------------
 
31
    // Variables
 
32
    // ------------------------------------------------------------------------
 
33
 
 
34
    private static final TmfEventTypeManager fInstance = TmfEventTypeManager.getInstance();
 
35
 
 
36
    private final String fContext1 = "JUnit context 1";
 
37
    private final String fContext2 = "JUnit context 2";
 
38
 
 
39
    private final String fTypeId1 = "Some type";
 
40
    private final String fTypeId2 = "Some other type";
 
41
    private final String fTypeId3 = "Yet another type";
 
42
    private final String fTypeId4 = "A final type";
 
43
 
 
44
    private final String fLabel0 = "label1";
 
45
    private final String fLabel1 = "label2";
 
46
 
 
47
    private final String[] fLabels0 = new String[] { };
 
48
    private final String[] fLabels1 = new String[] { fLabel0, fLabel1 };
 
49
    private final String[] fLabels2 = new String[] { fLabel1, fLabel0, fLabel1 };
 
50
 
 
51
    private final TmfEventType fType0 = new TmfEventType(fContext1, fTypeId1, TmfEventField.makeRoot(fLabels0));
 
52
    private final TmfEventType fType1 = new TmfEventType(fContext1, fTypeId2, TmfEventField.makeRoot(fLabels1));
 
53
    private final TmfEventType fType2 = new TmfEventType(fContext2, fTypeId3, TmfEventField.makeRoot(fLabels2));
 
54
    private final TmfEventType fType3 = new TmfEventType(fContext2, fTypeId4, TmfEventField.makeRoot(fLabels1));
 
55
 
 
56
    // ------------------------------------------------------------------------
 
57
    // Housekeeping
 
58
    // ------------------------------------------------------------------------
 
59
 
 
60
    /**
 
61
     * @param name the test name
 
62
     */
 
63
    public TmfEventTypeManagerTest(final String name) {
 
64
        super(name);
 
65
    }
 
66
 
 
67
    @Override
 
68
    protected void setUp() throws Exception {
 
69
        super.setUp();
 
70
    }
 
71
 
 
72
    @Override
 
73
    protected void tearDown() throws Exception {
 
74
        super.tearDown();
 
75
    }
 
76
 
 
77
    // ------------------------------------------------------------------------
 
78
    // Getters
 
79
    // ------------------------------------------------------------------------
 
80
 
 
81
    public void testGetContexts() {
 
82
        fInstance.clear();
 
83
        fInstance.add(fContext1, fType0);
 
84
        fInstance.add(fContext1, fType1);
 
85
        fInstance.add(fContext2, fType2);
 
86
        fInstance.add(fContext2, fType3);
 
87
 
 
88
        final String[] contexts = fInstance.getContexts();
 
89
        Arrays.sort(contexts);
 
90
        assertEquals("getContexts", 2, contexts.length);
 
91
        assertEquals("getContexts", fContext1, contexts[0]);
 
92
        assertEquals("getContexts", fContext2, contexts[1]);
 
93
    }
 
94
 
 
95
    public void testGetTypes() {
 
96
        fInstance.clear();
 
97
        fInstance.add(fContext1, fType0);
 
98
        fInstance.add(fContext1, fType1);
 
99
        fInstance.add(fContext2, fType2);
 
100
        fInstance.add(fContext2, fType3);
 
101
 
 
102
        ITmfEventType[] types = fInstance.getTypes(fContext1);
 
103
        assertEquals("getTypes", 2, types.length);
 
104
        if (fType0 == types[0])
 
105
            assertSame("getTypes", fType1, types[1]);
 
106
        else {
 
107
            assertSame("getTypes", fType0, types[1]);
 
108
            assertSame("getTypes", fType1, types[0]);
 
109
        }
 
110
 
 
111
        types = fInstance.getTypes(fContext2);
 
112
        assertEquals("getTypes", 2, types.length);
 
113
        if (fType2 == types[0])
 
114
            assertSame("getTypes", fType3, types[1]);
 
115
        else {
 
116
            assertSame("getTypes", fType2, types[1]);
 
117
            assertSame("getTypes", fType3, types[0]);
 
118
        }
 
119
    }
 
120
 
 
121
    public void testGetType() {
 
122
        fInstance.clear();
 
123
        fInstance.add(fContext1, fType0);
 
124
        fInstance.add(fContext1, fType1);
 
125
        fInstance.add(fContext2, fType2);
 
126
        fInstance.add(fContext2, fType3);
 
127
 
 
128
        ITmfEventType type = fInstance.getType(fContext1, fType0.getName());
 
129
        assertSame("getType", fType0, type);
 
130
        type = fInstance.getType(fContext1, fType1.getName());
 
131
        assertSame("getType", fType1, type);
 
132
        type = fInstance.getType(fContext1, fType2.getName());
 
133
        assertNull("getType", type);
 
134
        type = fInstance.getType(fContext1, fType3.getName());
 
135
        assertNull("getType", type);
 
136
 
 
137
        type = fInstance.getType(fContext2, fType2.getName());
 
138
        assertSame("getType", fType2, type);
 
139
        type = fInstance.getType(fContext2, fType3.getName());
 
140
        assertSame("getType", fType3, type);
 
141
        type = fInstance.getType(fContext2, fType0.getName());
 
142
        assertNull("getType", type);
 
143
        type = fInstance.getType(fContext2, fType1.getName());
 
144
        assertNull("getType", type);
 
145
    }
 
146
 
 
147
    // ------------------------------------------------------------------------
 
148
    // Operations
 
149
    // ------------------------------------------------------------------------
 
150
 
 
151
    public void testClear() {
 
152
        fInstance.clear();
 
153
        assertEquals("clear", 0, fInstance.getContexts().length);
 
154
        assertEquals("clear", 0, fInstance.getTypes(null).length);
 
155
        assertNull("clear", fInstance.getType(null, null));
 
156
        assertEquals("clear", "TmfEventTypeManager [fEventTypes={}]", fInstance.toString());
 
157
    }
 
158
 
 
159
    public void testClearContext() {
 
160
        fInstance.clear();
 
161
        fInstance.add(fContext1, fType0);
 
162
        fInstance.add(fContext1, fType1);
 
163
        fInstance.add(fContext2, fType2);
 
164
        fInstance.add(fContext2, fType3);
 
165
 
 
166
        fInstance.clear(fContext1);
 
167
 
 
168
        final String[] contexts = fInstance.getContexts();
 
169
        assertEquals("clear context", 1, contexts.length);
 
170
        assertEquals("clear context", fContext2, contexts[0]);
 
171
 
 
172
        ITmfEventType[] types = fInstance.getTypes(fContext1);
 
173
        assertEquals("clear context", 0, types.length);
 
174
 
 
175
        ITmfEventType type = fInstance.getType(fContext1, fType0.getName());
 
176
        assertNull("clear context", type);
 
177
        type = fInstance.getType(fContext1, fType1.getName());
 
178
        assertNull("clear context", type);
 
179
 
 
180
        types = fInstance.getTypes(fContext2);
 
181
        assertEquals("clear context", 2, types.length);
 
182
        if (fType2 == types[0])
 
183
            assertSame("clear context", fType3, types[1]);
 
184
        else {
 
185
            assertSame("clear context", fType2, types[1]);
 
186
            assertSame("clear context", fType3, types[0]);
 
187
        }
 
188
    }
 
189
 
 
190
    public void testBasicAdd() {
 
191
        fInstance.clear();
 
192
        fInstance.add(fContext1, fType0);
 
193
 
 
194
        final String[] contexts = fInstance.getContexts();
 
195
        assertEquals("add", 1, contexts.length);
 
196
        assertEquals("add", fContext1, contexts[0]);
 
197
 
 
198
        final ITmfEventType[] types = fInstance.getTypes(contexts[0]);
 
199
        assertEquals("add", 1, types.length);
 
200
        assertSame("add", fType0, types[0]);
 
201
 
 
202
        ITmfEventType type = fInstance.getType(contexts[0], fType0.getName());
 
203
        assertSame("add", fType0, type);
 
204
 
 
205
        type = fInstance.getType(contexts[0], fType1.getName());
 
206
        assertNotSame("add", fType0, type);
 
207
    }
 
208
 
 
209
    public void testAdd() {
 
210
        fInstance.clear();
 
211
        fInstance.add(fContext1, fType0);
 
212
        fInstance.add(fContext1, fType1);
 
213
        fInstance.add(fContext2, fType2);
 
214
        fInstance.add(fContext2, fType3);
 
215
 
 
216
        final String[] contexts = fInstance.getContexts();
 
217
        Arrays.sort(contexts);
 
218
        assertEquals("add", 2, contexts.length);
 
219
        assertEquals("add", fContext1, contexts[0]);
 
220
        assertEquals("add", fContext2, contexts[1]);
 
221
 
 
222
        ITmfEventType[] types = fInstance.getTypes(fContext1);
 
223
        assertEquals("add", 2, types.length);
 
224
        if (fType0 == types[0])
 
225
            assertSame("add", fType1, types[1]);
 
226
        else {
 
227
            assertSame("add", fType0, types[1]);
 
228
            assertSame("add", fType1, types[0]);
 
229
        }
 
230
 
 
231
        types = fInstance.getTypes(fContext2);
 
232
        assertEquals("add", 2, types.length);
 
233
        if (fType2 == types[0])
 
234
            assertSame("add", fType3, types[1]);
 
235
        else {
 
236
            assertSame("add", fType2, types[1]);
 
237
            assertSame("add", fType3, types[0]);
 
238
        }
 
239
 
 
240
        ITmfEventType type = fInstance.getType(fContext1, fType0.getName());
 
241
        assertSame("add", fType0, type);
 
242
        type = fInstance.getType(fContext1, fType1.getName());
 
243
        assertSame("add", fType1, type);
 
244
        type = fInstance.getType(fContext2, fType2.getName());
 
245
        assertSame("add", fType2, type);
 
246
        type = fInstance.getType(fContext2, fType3.getName());
 
247
        assertSame("add", fType3, type);
 
248
 
 
249
        type = fInstance.getType(fContext1, fType2.getName());
 
250
        assertNull("add", type);
 
251
        type = fInstance.getType(fContext2, fType0.getName());
 
252
        assertNull("add", type);
 
253
    }
 
254
 
 
255
    // ------------------------------------------------------------------------
 
256
    // Object
 
257
    // ------------------------------------------------------------------------
 
258
 
 
259
    public void testToString() {
 
260
        fInstance.clear();
 
261
        assertEquals("toString", "TmfEventTypeManager [fEventTypes={}]", fInstance.toString());
 
262
 
 
263
        fInstance.add(fContext1, fType0);
 
264
        assertEquals("toString", "TmfEventTypeManager [fEventTypes={" + fContext1 + "={" + fTypeId1 + "=" + fType0 + "}}]", fInstance.toString());
 
265
    }
 
266
 
 
267
}