--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/jdk/jfr/jvm/TestUnsupportedVM.java Tue May 15 20:24:34 2018 +0200
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package jdk.jfr.jvm;
+
+
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.concurrent.Callable;
+
+import jdk.jfr.AnnotationElement;
+import jdk.jfr.Configuration;
+import jdk.jfr.Description;
+import jdk.jfr.Event;
+import jdk.jfr.EventFactory;
+import jdk.jfr.EventSettings;
+import jdk.jfr.EventType;
+import jdk.jfr.FlightRecorder;
+import jdk.jfr.FlightRecorderListener;
+import jdk.jfr.FlightRecorderPermission;
+import jdk.jfr.Label;
+import jdk.jfr.Recording;
+import jdk.jfr.RecordingState;
+import jdk.jfr.SettingControl;
+import jdk.jfr.ValueDescriptor;
+import jdk.jfr.consumer.RecordedClass;
+import jdk.jfr.consumer.RecordedEvent;
+import jdk.jfr.consumer.RecordedFrame;
+import jdk.jfr.consumer.RecordedMethod;
+import jdk.jfr.consumer.RecordedObject;
+import jdk.jfr.consumer.RecordedStackTrace;
+import jdk.jfr.consumer.RecordedThread;
+import jdk.jfr.consumer.RecordedThreadGroup;
+import jdk.jfr.consumer.RecordingFile;
+import jdk.management.jfr.ConfigurationInfo;
+import jdk.management.jfr.EventTypeInfo;
+import jdk.management.jfr.FlightRecorderMXBean;
+import jdk.management.jfr.RecordingInfo;
+import jdk.management.jfr.SettingDescriptorInfo;
+
+/*
+ * @test TestUnsupportedVM
+ * @key jfr
+ *
+ * @modules jdk.jfr
+ * jdk.management.jfr
+ *
+ * @run main/othervm -Dprepare-recording=true jdk.jfr.jvm.TestUnsupportedVM
+ * @run main/othervm -Djfr.unsupported.vm=true jdk.jfr.jvm.TestUnsupportedVM
+ */
+public class TestUnsupportedVM {
+
+ private static Path RECORDING_FILE = Paths.get("recording.jfr");
+ private static Class<?> [] APIClasses = {
+ AnnotationElement.class,
+ Configuration.class,
+ ConfigurationInfo.class,
+ Event.class,
+ EventFactory.class,
+ EventSettings.class,
+ EventType.class,
+ EventTypeInfo.class,
+ FlightRecorder.class,
+ FlightRecorderPermission.class,
+ FlightRecorderListener.class,
+ FlightRecorderMXBean.class,
+ RecordedClass.class,
+ RecordedEvent.class,
+ RecordedFrame.class,
+ RecordedMethod.class,
+ RecordedObject.class,
+ RecordedStackTrace.class,
+ RecordedThread.class,
+ RecordedThreadGroup.class,
+ Recording.class,
+ RecordingFile.class,
+ RecordingInfo.class,
+ RecordingState.class,
+ SettingControl.class,
+ SettingDescriptorInfo.class,
+ ValueDescriptor.class
+ };
+ // * @run main/othervm -Dprepare-recording=true jdk.jfr.jvm.TestUnsupportedVM
+ @Label("My Event")
+ @Description("My fine event")
+ static class MyEvent extends Event {
+ int myValue;
+ }
+
+ public static void main(String... args) throws Exception {
+ if (Boolean.getBoolean("prepare-recording")) {
+ Recording r = new Recording(Configuration.getConfiguration("default"));
+ r.start();
+ r.stop();
+ r.dump(RECORDING_FILE);
+ r.close();
+ return;
+ }
+
+ System.out.println("jdk.jfr.unsupportedvm=" + System.getProperty("jdk.jfr.unsupportedvm"));
+ // Class FlightRecorder
+ if (FlightRecorder.isAvailable()) {
+ throw new AssertionError("JFR should not be available on an unsupported VM");
+ }
+
+ if (FlightRecorder.isInitialized()) {
+ throw new AssertionError("JFR should not be initialized on an unsupported VM");
+ }
+
+ assertIllegalStateException(() -> FlightRecorder.getFlightRecorder());
+ assertSwallow(() -> FlightRecorder.addListener(new FlightRecorderListener() {}));
+ assertSwallow(() -> FlightRecorder.removeListener(new FlightRecorderListener() {}));
+ assertSwallow(() -> FlightRecorder.register(MyEvent.class));
+ assertSwallow(() -> FlightRecorder.unregister(MyEvent.class));
+ assertSwallow(() -> FlightRecorder.addPeriodicEvent(MyEvent.class, new Runnable() { public void run() {} }));
+ assertSwallow(() -> FlightRecorder.removePeriodicEvent(new Runnable() { public void run() {} }));
+
+ // Class Configuration
+ if (!Configuration.getConfigurations().isEmpty()) {
+ throw new AssertionError("Configuration files should not exist on an unsupported VM");
+ }
+ Path jfcFile = Files.createTempFile("my", ".jfr");
+ assertIOException(() -> Configuration.getConfiguration("default"));
+ assertIOException(() -> Configuration.create(jfcFile));
+ assertIOException(() -> Configuration.create(new FileReader(jfcFile.toFile())));
+
+ // Class EventType
+ assertInternalError(() -> EventType.getEventType(MyEvent.class));
+
+ // Class EventFactory
+ assertInternalError(() -> EventFactory.create(new ArrayList<>(), new ArrayList<>()));
+
+ // Create a static event
+ MyEvent myEvent = new MyEvent();
+ myEvent.begin();
+ myEvent.end();
+ myEvent.shouldCommit();
+ myEvent.commit();
+
+ // Trigger class initialization failure
+ for (Class<?> c : APIClasses) {
+ assertNoClassInitFailure(c);
+ }
+
+ // jdk.jfr.consumer.*
+ // Only run this part of tests if we are on VM
+ // that can produce a recording file
+ if (Files.exists(RECORDING_FILE)) {
+ for(RecordedEvent re : RecordingFile.readAllEvents(RECORDING_FILE)) {
+ System.out.println(re);
+ }
+ }
+ }
+
+ private static void assertNoClassInitFailure(Class<?> clazz) {
+ try {
+ Class.forName(clazz.getName(), true, clazz.getClassLoader());
+ } catch (ClassNotFoundException e) {
+ throw new AssertionError("Could not find public API class on unsupported VM");
+ }
+ }
+
+ private static void assertInternalError(Runnable r) {
+ try {
+ r.run();
+ } catch (InternalError e) {
+ // OK, as expected
+ return;
+ }
+ throw new AssertionError("Expected InternalError on an unsupported JVM");
+ }
+
+ private static void assertIOException(Callable<?> c) {
+ try {
+ c.call();
+ } catch (Exception e) {
+ if (e.getClass() == IOException.class) {
+ return;
+ }
+ }
+ throw new AssertionError("Expected IOException on an unsupported JVM");
+ }
+
+ private static void assertIllegalStateException(Runnable r) throws Exception {
+ try {
+ r.run();
+ } catch (IllegalStateException ise) {
+ if (!ise.getMessage().equals("Flight Recorder is not supported on this VM")) {
+ throw new AssertionError("Expected 'Flight Recorder is not supported on this VM'");
+ }
+ }
+ }
+
+ private static void assertSwallow(Runnable r) throws Exception {
+ try {
+ r.run();
+ } catch (Exception e) {
+ throw new AssertionError("Unexpected exception '" + e.getMessage() + " on an unspported VM");
+ }
+ }
+}