1 /*
2 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.jfr.api.consumer;
27
28 import java.io.IOException;
29 import java.time.Duration;
30 import java.time.Instant;
31 import java.util.Arrays;
32 import java.util.HashSet;
33 import java.util.List;
34 import java.util.Set;
35 import java.util.function.Function;
36
37 import jdk.jfr.Event;
38 import jdk.jfr.Recording;
39 import jdk.jfr.StackTrace;
40 import jdk.jfr.Timespan;
41 import jdk.jfr.Timestamp;
42 import jdk.jfr.Unsigned;
43 import jdk.jfr.consumer.RecordedClass;
44 import jdk.jfr.consumer.RecordedEvent;
45 import jdk.jfr.consumer.RecordedObject;
46 import jdk.jfr.consumer.RecordedThread;
47 import jdk.test.lib.Asserts;
48 import jdk.test.lib.jfr.Events;
49
50 /*
51 * @test
52 * @summary Verifies the methods of the RecordedObject
53 * @key jfr
54 * @library /test/lib
55 * @run main/othervm jdk.jfr.api.consumer.TestRecordedObject
56 */
57 public class TestRecordedObject {
58
59 private final static boolean BOOLEAN_VALUE = true;
60 private final static byte VALUE = 47;
61 private final static String STRING_VALUE = "47";
62 private final static Class<?> CLASS_VALUE = String.class;
63 private final static Thread THREAD_VALUE = Thread.currentThread();
64 private final static Instant INSTANT_VALUE = Instant.now();
65 private final static Duration DURATION_VALUE = Duration.ofSeconds(47);
66
67 @StackTrace(false)
68 static final class EventWithValues extends Event {
69 boolean booleanField = BOOLEAN_VALUE;
70 byte byteField = VALUE;
71 char charField = VALUE;
72 short shortField = VALUE;
73 int intField = VALUE;
74 long longField = VALUE;
75 float floatField = VALUE;
76 double doubleField = VALUE;
77 String stringField = STRING_VALUE;
78 Class<?> classField = CLASS_VALUE;
79 Thread threadField = THREAD_VALUE;
80 @Timespan(Timespan.NANOSECONDS)
81 long durationField = DURATION_VALUE.toNanos();
82 @Timestamp(Timestamp.MILLISECONDS_SINCE_EPOCH)
83 long instantField = INSTANT_VALUE.toEpochMilli();
84 Thread nullField = null;
85 Class<?> nullField2 = null;
86
87 @Timespan(Timespan.MICROSECONDS)
88 long durationMicros = DURATION_VALUE.toNanos() / 1000;
89
90 @Timespan(Timespan.MILLISECONDS)
91 long durationMillis = DURATION_VALUE.toMillis();
92
93 @Timespan(Timespan.SECONDS)
94 long durationSeconds = DURATION_VALUE.toSeconds();
95
96 @Timestamp(Timestamp.MILLISECONDS_SINCE_EPOCH)
97 long instantMillis = 1000;
98
99 @Timestamp(Timespan.TICKS)
100 long instantTicks = 0;
101
102 @Unsigned
103 byte unsignedByte = Byte.MIN_VALUE;
104 @Unsigned
105 char unsignedChar = 'q';
106 @Unsigned
107 short unsignedShort = Short.MIN_VALUE;
108 @Unsigned
109 int unsignedInt = Integer.MIN_VALUE;
110 @Unsigned
111 long unsignedLong = Long.MIN_VALUE; // unsigned should be ignored
112 @Unsigned
113 float unsignedFloat = Float.MIN_VALUE; // unsigned should be ignored
114 @Unsigned
115 double unsignedDouble = Double.MIN_VALUE; // unsigned should be ignored
116
117 }
118
119 private final static Set<String> ALL = createAll();
120
121 public static void main(String[] args) throws Throwable {
122
123 RecordedObject event = makeRecordedObject();
124
125 // Primitives
126 testGetBoolean(event);
127 testGetByte(event);
128 testGetChar(event);
129 testGetShort(event);
130 testGetInt(event);
131 testGetLong(event);
132 testGetDouble(event);
133 testGetFloat(event);
134
135 // // Complex types
136 testGetString(event);
137 testGetInstant(event);
138 testGetDuration(event);
139 testGetThread(event);
140 testGetClass(event);
141
142 // Misc.
143 testNestedNames(event);
144 testTimeUnits(event);
145 testUnsigned(event);
146 }
147
148 private static void testUnsigned(RecordedObject event) {
149 // Unsigned byte value
150 Asserts.assertEquals(event.getByte("unsignedByte"), Byte.MIN_VALUE);
151 Asserts.assertEquals(event.getInt("unsignedByte"), Byte.toUnsignedInt(Byte.MIN_VALUE));
152 Asserts.assertEquals(event.getLong("unsignedByte"), Byte.toUnsignedLong(Byte.MIN_VALUE));
153 Asserts.assertEquals(event.getShort("unsignedByte"), (short)Byte.toUnsignedInt(Byte.MIN_VALUE));
154
155 // Unsigned char, nothing should happen, it is unsigned
156 Asserts.assertEquals(event.getChar("unsignedChar"), 'q');
157 Asserts.assertEquals(event.getInt("unsignedChar"), (int)'q');
158 Asserts.assertEquals(event.getLong("unsignedChar"), (long)'q');
159
160 // Unsigned short
161 Asserts.assertEquals(event.getShort("unsignedShort"), Short.MIN_VALUE);
162 Asserts.assertEquals(event.getInt("unsignedShort"), Short.toUnsignedInt(Short.MIN_VALUE));
163 Asserts.assertEquals(event.getLong("unsignedShort"), Short.toUnsignedLong(Short.MIN_VALUE));
164
165 // Unsigned int
166 Asserts.assertEquals(event.getInt("unsignedInt"), Integer.MIN_VALUE);
167 Asserts.assertEquals(event.getLong("unsignedInt"), Integer.toUnsignedLong(Integer.MIN_VALUE));
168
169 // Unsigned long, nothing should happen
170 Asserts.assertEquals(event.getLong("unsignedLong"), Long.MIN_VALUE);
171
172 // Unsigned float, nothing should happen
173 Asserts.assertEquals(event.getFloat("unsignedFloat"), Float.MIN_VALUE);
174
175 // Unsigned double, nothing should happen
176 Asserts.assertEquals(event.getDouble("unsignedDouble"), Double.MIN_VALUE);
177 }
178
179 private static void testTimeUnits(RecordedObject event) {
180 Asserts.assertEquals(event.getDuration("durationMicros"), DURATION_VALUE);
181 Asserts.assertEquals(event.getDuration("durationMillis"), DURATION_VALUE);
182 Asserts.assertEquals(event.getDuration("durationSeconds"), DURATION_VALUE);
183 Asserts.assertEquals(event.getInstant("instantMillis").toEpochMilli(), 1000L);
184 if (!event.getInstant("instantTicks").isBefore(INSTANT_VALUE)) {
185 throw new AssertionError("Expected start time of JVM to before call to Instant.now()");
186 }
187 }
188
189 private static void testNestedNames(RecordedObject event) {
190 RecordedThread t = event.getValue("threadField");
191
192 // Nested with getValue
193 try {
194 event.getValue("nullField.javaName");
195 throw new AssertionError("Expected NullPointerException");
196 } catch (NullPointerException npe) {
197 // OK, expected;
198 }
199 try {
200 event.getValue("nullField.does.not.exist");
201 throw new AssertionError("Expected IllegalArgumentException");
202 } catch (IllegalArgumentException iae) {
203 // OK, expected;
204 }
205
206 // Nested getLong
207 try {
208 event.getLong("nullField.javaName");
209 throw new AssertionError("Expected NullPointerException");
210 } catch (NullPointerException npe) {
211 // OK, expected;
212 }
213 try {
214 event.getLong("nullField.does.not.exist");
215 throw new AssertionError("Expected IllegalArgumentException");
216 } catch (IllegalArgumentException npe) {
217 // OK, expected;
218 }
219 if (t.getOSThreadId() != event.getLong("threadField.osThreadId")) {
220 throw new AssertionError("Incorrect result from nested long value");
221 }
222
223 // Nested getString
224 try {
225 event.getString("nullField.osThreadId");
226 throw new AssertionError("Expected IllegalArgumentException");
227 } catch (IllegalArgumentException npe) {
228 // OK, expected;
229 }
230 try {
231 event.getLong("nullField.does.not.exist");
232 throw new AssertionError("Expected IllegalArgumentException");
233 } catch (IllegalArgumentException npe) {
234 // OK, expected;
235 }
236 if (!t.getJavaName().equals(event.getString("threadField.javaName"))) {
237 throw new AssertionError("Incorrect result from nested long value");
238 }
239
240 // Nested getClass
241 try {
242 event.getClass("nullField.osThreadId");
243 throw new AssertionError("Expected IllegalArgumentException");
244 } catch (IllegalArgumentException npe) {
245 // OK, expected;
246 }
247 try {
248 event.getClass("nullField.does.not.exist");
249 throw new AssertionError("Expected IllegalArgumentException");
250 } catch (IllegalArgumentException npe) {
251 // OK, expected;
252 }
253
254 // Nested getThread
255 try {
256 event.getThread("nullField2.name");
257 throw new AssertionError("Expected IllegalArgumentException");
258 } catch (IllegalArgumentException npe) {
259 // OK, expected;
260 }
261 try {
262 event.getThread("nullField2.does.not.exist");
263 throw new AssertionError("Expected IllegalArgumentException");
264 } catch (IllegalArgumentException npe) {
265 // OK, expected;
266 }
267 }
268
269 private static void testGetBoolean(RecordedObject e) {
270 assertGetter(x -> e.getBoolean(x), BOOLEAN_VALUE, "boolean");
271 }
272
273 private static void testGetByte(RecordedObject e) {
274 assertGetter(x -> e.getByte(x), (byte) VALUE, "byte");
275 }
276
277 private static void testGetChar(RecordedObject e) {
278 assertGetter(x -> e.getChar(x), (char) VALUE, "char");
279 }
280
281 private static void testGetShort(RecordedObject e) {
282 assertGetter(x -> e.getShort(x), (short) VALUE, "byte", "short");
283 }
284
285 private static void testGetInt(RecordedObject e) {
286 assertGetter(x -> e.getInt(x), (int) VALUE, "byte", "char", "short", "int");
287 }
288
289 private static void testGetLong(RecordedObject e) {
290 assertGetter(x -> e.getLong(x), (long) VALUE, "byte", "char", "short", "int", "long");
291 }
292
293 private static void testGetFloat(RecordedObject e) {
294 assertGetter(x -> e.getFloat(x), (float) VALUE, "byte", "char", "short", "int", "long", "float");
295 }
296
297 private static void testGetDouble(RecordedObject e) {
298 assertGetter(x -> e.getDouble(x), (double) VALUE, "byte", "char", "short", "int", "long", "float", "double");
299 }
300
301 private static void testGetString(RecordedObject e) {
302 assertGetter(x -> e.getString(x), STRING_VALUE, "string");
303 }
304
305 private static void testGetInstant(RecordedObject e) {
306 assertGetter(x -> e.getInstant(x), Instant.ofEpochMilli(INSTANT_VALUE.toEpochMilli()), "instant");
307 }
308
309 private static void testGetDuration(RecordedObject e) {
310 assertGetter(x -> e.getDuration(x), DURATION_VALUE, "duration");
311 }
312
313 private static void testGetThread(RecordedObject e) {
314 RecordedThread thread = e.getValue("threadField");
315 if (!thread.getJavaName().equals(THREAD_VALUE.getName())) {
316 throw new AssertionError("Expected thread to have name " + THREAD_VALUE.getName());
317 }
318 assertGetter(x -> {
319 // OK to access nullField if it is correct type
320 // Chose a second null field with class type
321 if ("nullField".equals(x)) {
322 return e.getThread("nullField2");
323 } else {
324 return e.getThread(x);
325 }
326
327 }, thread, "thread");
328 }
329
330 private static void testGetClass(RecordedObject e) {
331 RecordedClass clazz = e.getValue("classField");
332 if (!clazz.getName().equals(CLASS_VALUE.getName())) {
333 throw new AssertionError("Expected class to have name " + CLASS_VALUE.getName());
334 }
335 assertGetter(x -> e.getClass(x), clazz, "class");
336 }
337
338 private static <T> void assertGetter(Function<String, T> f, T expectedValue, String... validTypes) {
339 Set<String> valids = new HashSet<String>(Arrays.asList(validTypes));
340 Set<String> invalids = new HashSet<String>(ALL);
341 invalids.removeAll(valids);
342 for (String valid : valids) {
343 T result = f.apply(valid + "Field");
344 if (!expectedValue.equals(result)) {
345 throw new AssertionError("Incorrect return value " + result + ". Expected " + expectedValue);
346 }
347 }
348 for (String invalid : invalids) {
349 try {
350 f.apply(invalid + "Field");
351 } catch (IllegalArgumentException iae) {
352 // OK, as expected
353 } catch (Exception e) {
354 throw new AssertionError("Unexpected exception for invalid field " + invalid + ". " + e.getClass().getName() + " : " + e.getMessage(), e);
355 }
356 }
357 String[] illegals = { "missingField", "nullField.javaName.does.not.exist", "nullField" };
358 for (String illegal : illegals) {
359 try {
360 f.apply(illegal);
361 throw new AssertionError("Expected IllegalArgumentException when accessing " + illegal);
362 } catch (IllegalArgumentException iae) {
363 // OK, as expected
364 } catch (Exception e) {
365 throw new AssertionError("Expected IllegalArgumentException. Got " + e.getClass().getName() + " : " + e.getMessage(), e);
366 }
367 }
368 try {
369 f.apply(null);
370 throw new AssertionError("Expected NullpointerException exception when passing in null value");
371 } catch (NullPointerException iae) {
372 // OK, as expected
373 } catch (Exception e) {
374 throw new AssertionError("Expected NullpointerException. Got " + e.getClass().getName() + " : " + e.getMessage(), e);
375 }
376 }
377
378 private static RecordedObject makeRecordedObject() throws IOException {
379 Recording r = new Recording();
380 r.start();
381 EventWithValues t = new EventWithValues();
382 t.commit();
383 r.stop();
384 List<RecordedEvent> events = Events.fromRecording(r);
385 Events.hasEvents(events);
386 return events.get(0);
387 }
388
389 private static Set<String> createAll() {
390 Set<String> set = new HashSet<>();
391 set.add("boolean");
392 set.add("byte");
393 set.add("char");
394 set.add("short");
395 set.add("int");
396 set.add("long");
397 set.add("float");
398 set.add("double");
399 set.add("string");
400 set.add("class");
401 set.add("thread");
402 set.add("instant");
403 set.add("duration");
404 return set;
405 }
406 }