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  *
  55  * @library /lib /
  56  * @run main/othervm jdk.jfr.api.consumer.TestRecordedObject
  57  */
  58 public class TestRecordedObject {
  59 
  60     private final static boolean BOOLEAN_VALUE = true;
  61     private final static byte VALUE = 47;
  62     private final static String STRING_VALUE = "47";
  63     private final static Class<?> CLASS_VALUE = String.class;
  64     private final static Thread THREAD_VALUE = Thread.currentThread();
  65     private final static Instant INSTANT_VALUE = Instant.now();
  66     private final static Duration DURATION_VALUE = Duration.ofSeconds(47);
  67 
  68     @StackTrace(false)
  69     static final class EventWithValues extends Event {
  70         boolean booleanField = BOOLEAN_VALUE;
  71         byte byteField = VALUE;
  72         char charField = VALUE;
  73         short shortField = VALUE;
  74         int intField = VALUE;
  75         long longField = VALUE;
  76         float floatField = VALUE;
  77         double doubleField = VALUE;
  78         String stringField = STRING_VALUE;
  79         Class<?> classField = CLASS_VALUE;
  80         Thread threadField = THREAD_VALUE;
  81         @Timespan(Timespan.NANOSECONDS)
  82         long durationField = DURATION_VALUE.toNanos();
  83         @Timestamp(Timestamp.MILLISECONDS_SINCE_EPOCH)
  84         long instantField = INSTANT_VALUE.toEpochMilli();
  85         Thread nullField = null;
  86         Class<?> nullField2 = null;
  87 
  88         @Timespan(Timespan.MICROSECONDS)
  89         long durationMicros = DURATION_VALUE.toNanos() / 1000;
  90 
  91         @Timespan(Timespan.MILLISECONDS)
  92         long durationMillis = DURATION_VALUE.toMillis();
  93 
  94         @Timespan(Timespan.SECONDS)
  95         //long durationSeconds = (DURATION_VALUE.toMinutes() * 60);
  96         long durationSeconds = DURATION_VALUE.toMillis() / 1000;
  97 
  98         @Timestamp(Timestamp.MILLISECONDS_SINCE_EPOCH)
  99         long instantMillis = 1000;
 100 
 101         @Timestamp(Timespan.TICKS)
 102         long instantTicks = 0;
 103 
 104         @Unsigned
 105         byte unsignedByte = Byte.MIN_VALUE;
 106         @Unsigned
 107         char unsignedChar = 'q';
 108         @Unsigned
 109         short unsignedShort = Short.MIN_VALUE;
 110         @Unsigned
 111         int unsignedInt = Integer.MIN_VALUE;
 112         @Unsigned
 113         long unsignedLong = Long.MIN_VALUE; // unsigned should be ignored
 114         @Unsigned
 115         float unsignedFloat = Float.MIN_VALUE; // unsigned should be ignored
 116         @Unsigned
 117         double unsignedDouble = Double.MIN_VALUE; // unsigned should be ignored
 118 
 119     }
 120 
 121     private final static Set<String> ALL = createAll();
 122 
 123     public static void main(String[] args) throws Throwable {
 124 
 125         RecordedObject event = makeRecordedObject();
 126 
 127         // Primitives
 128         testGetBoolean(event);
 129         testGetByte(event);
 130         testGetChar(event);
 131         testGetShort(event);
 132         testGetInt(event);
 133         testGetLong(event);
 134         testGetDouble(event);
 135         testGetFloat(event);
 136 
 137         // // Complex types
 138         testGetString(event);
 139         testGetInstant(event);
 140         testGetDuration(event);
 141         testGetThread(event);
 142         testGetClass(event);
 143 
 144         // Misc.
 145         testNestedNames(event);
 146         testTimeUnits(event);
 147         testUnsigned(event);
 148     }
 149 
 150     private static void testUnsigned(RecordedObject event) {
 151         // Unsigned byte value
 152         Asserts.assertEquals(event.getByte("unsignedByte"), Byte.MIN_VALUE);
 153         Asserts.assertEquals(event.getInt("unsignedByte"), Byte.toUnsignedInt(Byte.MIN_VALUE));
 154         Asserts.assertEquals(event.getLong("unsignedByte"), Byte.toUnsignedLong(Byte.MIN_VALUE));
 155         Asserts.assertEquals(event.getShort("unsignedByte"), (short)Byte.toUnsignedInt(Byte.MIN_VALUE));
 156 
 157         // Unsigned char, nothing should happen, it is unsigned
 158         Asserts.assertEquals(event.getChar("unsignedChar"), 'q');
 159         Asserts.assertEquals(event.getInt("unsignedChar"), (int)'q');
 160         Asserts.assertEquals(event.getLong("unsignedChar"), (long)'q');
 161 
 162         // Unsigned short
 163         Asserts.assertEquals(event.getShort("unsignedShort"), Short.MIN_VALUE);
 164         Asserts.assertEquals(event.getInt("unsignedShort"), Short.toUnsignedInt(Short.MIN_VALUE));
 165         Asserts.assertEquals(event.getLong("unsignedShort"), Short.toUnsignedLong(Short.MIN_VALUE));
 166 
 167         // Unsigned int
 168         Asserts.assertEquals(event.getInt("unsignedInt"), Integer.MIN_VALUE);
 169         Asserts.assertEquals(event.getLong("unsignedInt"), Integer.toUnsignedLong(Integer.MIN_VALUE));
 170 
 171         // Unsigned long, nothing should happen
 172         Asserts.assertEquals(event.getLong("unsignedLong"), Long.MIN_VALUE);
 173 
 174         // Unsigned float, nothing should happen
 175         Asserts.assertEquals(event.getFloat("unsignedFloat"), Float.MIN_VALUE);
 176 
 177         // Unsigned double, nothing should happen
 178         Asserts.assertEquals(event.getDouble("unsignedDouble"), Double.MIN_VALUE);
 179     }
 180 
 181     private static void testTimeUnits(RecordedObject event) {
 182         Asserts.assertEquals(event.getDuration("durationMicros"), DURATION_VALUE);
 183         Asserts.assertEquals(event.getDuration("durationMillis"), DURATION_VALUE);
 184         Asserts.assertEquals(event.getDuration("durationSeconds"), DURATION_VALUE);
 185         Asserts.assertEquals(event.getInstant("instantMillis").toEpochMilli(), 1000L);
 186         if (!event.getInstant("instantTicks").isBefore(INSTANT_VALUE)) {
 187             throw new AssertionError("Expected start time of JVM to before call to Instant.now()");
 188         }
 189     }
 190 
 191     private static void testNestedNames(RecordedObject event) {
 192         RecordedThread t = event.getValue("threadField");
 193 
 194         // Nested with getValue
 195         try {
 196             event.getValue("nullField.javaName");
 197             throw new AssertionError("Expected NullPointerException");
 198         } catch (NullPointerException npe) {
 199             // OK, expected;
 200         }
 201         try {
 202             event.getValue("nullField.does.not.exist");
 203             throw new AssertionError("Expected IllegalArgumentException");
 204         } catch (IllegalArgumentException iae) {
 205             // OK, expected;
 206         }
 207 
 208         // Nested getLong
 209         try {
 210             event.getLong("nullField.javaName");
 211             throw new AssertionError("Expected NullPointerException");
 212         } catch (NullPointerException npe) {
 213             // OK, expected;
 214         }
 215         try {
 216             event.getLong("nullField.does.not.exist");
 217             throw new AssertionError("Expected IllegalArgumentException");
 218         } catch (IllegalArgumentException npe) {
 219             // OK, expected;
 220         }
 221         if (t.getOSThreadId() != event.getLong("threadField.osThreadId")) {
 222             throw new AssertionError("Incorrect result from nested long value");
 223         }
 224 
 225         // Nested getString
 226         try {
 227             event.getString("nullField.osThreadId");
 228             throw new AssertionError("Expected IllegalArgumentException");
 229         } catch (IllegalArgumentException npe) {
 230             // OK, expected;
 231         }
 232         try {
 233             event.getLong("nullField.does.not.exist");
 234             throw new AssertionError("Expected IllegalArgumentException");
 235         } catch (IllegalArgumentException npe) {
 236             // OK, expected;
 237         }
 238         if (!t.getJavaName().equals(event.getString("threadField.javaName"))) {
 239             throw new AssertionError("Incorrect result from nested long value");
 240         }
 241 
 242         // Nested getClass
 243         try {
 244             event.getClass("nullField.osThreadId");
 245             throw new AssertionError("Expected IllegalArgumentException");
 246         } catch (IllegalArgumentException npe) {
 247             // OK, expected;
 248         }
 249         try {
 250             event.getClass("nullField.does.not.exist");
 251             throw new AssertionError("Expected IllegalArgumentException");
 252         } catch (IllegalArgumentException npe) {
 253             // OK, expected;
 254         }
 255 
 256         // Nested getThread
 257         try {
 258             event.getThread("nullField2.name");
 259             throw new AssertionError("Expected IllegalArgumentException");
 260         } catch (IllegalArgumentException npe) {
 261             // OK, expected;
 262         }
 263         try {
 264             event.getThread("nullField2.does.not.exist");
 265             throw new AssertionError("Expected IllegalArgumentException");
 266         } catch (IllegalArgumentException npe) {
 267             // OK, expected;
 268         }
 269     }
 270 
 271     private static void testGetBoolean(RecordedObject e) {
 272         assertGetter(x -> e.getBoolean(x), BOOLEAN_VALUE, "boolean");
 273     }
 274 
 275     private static void testGetByte(RecordedObject e) {
 276         assertGetter(x -> e.getByte(x), (byte) VALUE, "byte");
 277     }
 278 
 279     private static void testGetChar(RecordedObject e) {
 280         assertGetter(x -> e.getChar(x), (char) VALUE, "char");
 281     }
 282 
 283     private static void testGetShort(RecordedObject e) {
 284         assertGetter(x -> e.getShort(x), (short) VALUE, "byte", "short");
 285     }
 286 
 287     private static void testGetInt(RecordedObject e) {
 288         assertGetter(x -> e.getInt(x), (int) VALUE, "byte", "char", "short", "int");
 289     }
 290 
 291     private static void testGetLong(RecordedObject e) {
 292         assertGetter(x -> e.getLong(x), (long) VALUE, "byte", "char", "short", "int", "long");
 293     }
 294 
 295     private static void testGetFloat(RecordedObject e) {
 296         assertGetter(x -> e.getFloat(x), (float) VALUE, "byte", "char", "short", "int", "long", "float");
 297     }
 298 
 299     private static void testGetDouble(RecordedObject e) {
 300         assertGetter(x -> e.getDouble(x), (double) VALUE, "byte", "char", "short", "int", "long", "float", "double");
 301     }
 302 
 303     private static void testGetString(RecordedObject e) {
 304         assertGetter(x -> e.getString(x), STRING_VALUE, "string");
 305     }
 306 
 307     private static void testGetInstant(RecordedObject e) {
 308         assertGetter(x -> e.getInstant(x), Instant.ofEpochMilli(INSTANT_VALUE.toEpochMilli()), "instant");
 309     }
 310 
 311     private static void testGetDuration(RecordedObject e) {
 312         assertGetter(x -> e.getDuration(x), DURATION_VALUE, "duration");
 313     }
 314 
 315     private static void testGetThread(RecordedObject e) {
 316         RecordedThread thread = e.getValue("threadField");
 317         if (!thread.getJavaName().equals(THREAD_VALUE.getName())) {
 318             throw new AssertionError("Expected thread to have name " + THREAD_VALUE.getName());
 319         }
 320         assertGetter(x -> {
 321             // OK to access nullField if it is correct type
 322             // Chose a second null field with class type
 323             if ("nullField".equals(x)) {
 324                 return e.getThread("nullField2");
 325             } else {
 326                 return e.getThread(x);
 327             }
 328 
 329         }, thread, "thread");
 330     }
 331 
 332     private static void testGetClass(RecordedObject e) {
 333         RecordedClass clazz = e.getValue("classField");
 334         if (!clazz.getName().equals(CLASS_VALUE.getName())) {
 335             throw new AssertionError("Expected class to have name " + CLASS_VALUE.getName());
 336         }
 337         assertGetter(x -> e.getClass(x), clazz, "class");
 338     }
 339 
 340     private static <T> void assertGetter(Function<String, T> f, T expectedValue, String... validTypes) {
 341         Set<String> valids = new HashSet<String>(Arrays.asList(validTypes));
 342         Set<String> invalids = new HashSet<String>(ALL);
 343         invalids.removeAll(valids);
 344         for (String valid : valids) {
 345             T result = f.apply(valid + "Field");
 346             if (!expectedValue.equals(result)) {
 347                 throw new AssertionError("Incorrect return value " + result + ". Expected " + expectedValue);
 348             }
 349         }
 350         for (String invalid : invalids) {
 351             try {
 352                 f.apply(invalid + "Field");
 353             } catch (IllegalArgumentException iae) {
 354                 // OK, as expected
 355             } catch (Exception e) {
 356                 throw new AssertionError("Unexpected exception for invalid field " + invalid + ". " + e.getClass().getName() + " : " + e.getMessage(), e);
 357             }
 358         }
 359         String[] illegals = { "missingField", "nullField.javaName.does.not.exist", "nullField" };
 360         for (String illegal : illegals) {
 361             try {
 362                 f.apply(illegal);
 363                 throw new AssertionError("Expected IllegalArgumentException when accessing " + illegal);
 364             } catch (IllegalArgumentException iae) {
 365                 // OK, as expected
 366             } catch (Exception e) {
 367                 throw new AssertionError("Expected IllegalArgumentException. Got " + e.getClass().getName() + " : " + e.getMessage(), e);
 368             }
 369         }
 370         try {
 371             f.apply(null);
 372             throw new AssertionError("Expected NullpointerException exception when passing in null value");
 373         } catch (NullPointerException iae) {
 374             // OK, as expected
 375         } catch (Exception e) {
 376             throw new AssertionError("Expected NullpointerException. Got " + e.getClass().getName() + " : " + e.getMessage(), e);
 377         }
 378     }
 379 
 380     private static RecordedObject makeRecordedObject() throws IOException {
 381         Recording r = new Recording();
 382         r.start();
 383         EventWithValues t = new EventWithValues();
 384         t.commit();
 385         r.stop();
 386         List<RecordedEvent> events = Events.fromRecording(r);
 387         Events.hasEvents(events);
 388         return events.get(0);
 389     }
 390 
 391     private static Set<String> createAll() {
 392         Set<String> set = new HashSet<>();
 393         set.add("boolean");
 394         set.add("byte");
 395         set.add("char");
 396         set.add("short");
 397         set.add("int");
 398         set.add("long");
 399         set.add("float");
 400         set.add("double");
 401         set.add("string");
 402         set.add("class");
 403         set.add("thread");
 404         set.add("instant");
 405         set.add("duration");
 406         return set;
 407     }
 408 }