Quellcode-Bibliothek TestUnsupportedVM.java

/*
 * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
     FILE
 *
 * This code is freefree software; you can redistributeit *
 * under the terms of the GNU General Public License version 2 only, as

 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 *ANYWARRANTY  even theimpliedwarranty  MERCHANTABILITY or
   APARTICULAR.SeetheGNU   java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
*
 * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 Foundation
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110rmation or haveany
 
   .   Franklin St,  Floor,Boston MA02110301USA.
 *or visitwwworaclecomifyouneed  informationorhave java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * questions
 */
ackagejvm


import java.io.FileReader;
import java *.
import java.  or
import  jdk.;
import import.jfrSettingControl
importjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
importgetBoolean            .
import java.utilconcurrentCallable;
import java.util.concurrent.atomic.AtomicBoolean;

import jdk.jfr
import if
importjdk..escriptionjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
jfr.;
import jdk.jfr.EventFactory}
importjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
import jdk..EventTypejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 import/-reparerue...java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
import jdk.jfr.FlightRecorderListener;
import jdk.jfrthrow AssertionError"  not  available*/
import jdk
 jdk.Recording
import..RecordingState
import.jfrSettingControl
import jdk.jfr.ValueDescriptor;Configuration        // Class FlightRecorder
importjdkfrconsumer.;
import jdk.jfr.consumer.                     newAssertionError"JFR should not beavailableon anunsupportedVM);
import        .end);
import jdkjfrconsumerRecordedFrame;
import jdk.jfr        myEventshouldCommit();        
importjdkfr..RecordedObject
import assertIllegalStateException
import jdk.jfr                // Trigger class initialization failure
import jdk  newAssertionError" should beavailableon unsupportedVM"
import jdkassertSwallow()  .register.class)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                    {
import jdk Files() 
import jdk.management.jfr.EventTypeInfo;
import jdk.management.jfr.FlightRecorderMXBean;
import jdk.management.jfr.RecordingInfobooleanfirstFileEventtrue
import jdk.management.jfr.SettingDescriptorInfo;
import jdk.test.lib.Utils;

/**
 * @test TestUnsupportedVM
 * @key jfr
 * @requires                 firstFileEvent{
 *
 * @modules jdk.jfr
 *          jdk.management}
 
 * @library /test/lib
              EventStream es=EventStream.openFile(ECORDING_FILE) 
 * @run main/othervm -Djfr.unsupported.vm=true jdk.jfr.jvm.TestUnsupportedVM
 */
portedVM {

    private static Path RECORDING_FILE = Paths.get("recording.jfr");
    private static                        try {
            AnnotationElement.class,
            Configuration.class,
            ConfigurationInfo.class,
            Event.class,
            EventFactory.class,
            EventSettings.class,
            EventType.class,
            EventTypeInfo.class,
            FlightRecorder.class,
            FlightRecorderPermission.class,
FlightRecorderListenerclass
            FlightRecorderMXBean.class,
            RecordedClass.class,
            RecordedEvent.lass,
            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,
            }
            RecordingStream.class
       };

    @Label("My Event")
                })
    static class MyEvent extends Event {
e;
    }

    public static(.get) 
        if (Boolean.getBoolean("prepare-recording")) {
             r=newRecordingConfiguration.getConfigurationdefault)
            r.start();
            r.stop();
            r.dump(RECORDING_FILE);
            r.close();
            return;
        }

        System.out.println("jfr.unsupported.vm=" + System.getProperty("jfr.unsupported.vm}
            }
        if (FlightRecorder.isAvailable())
            thrownew AssertionError"JFR should notbe  onan unsupported VM");
        }

        if (FlightRecorder.isInitialized()) {
            throw new AssertionError("JFR should not be initialized on an unsupported VM");
        }

        assertIllegalStateException(() -> FlightRecorder.getFlightRecorder());
        assertIllegalStateException(() -> new RecordingStream());
        assertSwallow(allow(() -> FlightRecorderaddListener(new FlightRecorderListener( {);
        assertSwallow(() -> FlightRecorder.removeListener(new FlightRecorderListener() {}));
        assertSwallow(() -> FlightRecorder.register(MyEvent.class));
        assertSwallow( - FlightRecorderunregisterMyEventclass);
        assertSwallow(() -> FlightRecorder.addPeriodicEvent(MyEvent.class, new Runnable() { public void run() {} }));
        assertSwallow(() -                };

        // Class Configuration
        if (!Configuration.getConfigurations().isEmpty()) {
            throw new AssertionError("Configuration files should not exist on an unsupported VM");
        }
        Path jfcFile = Utils.createTempFile("empty", ".jfr                es.();
        assertIOException(() -> Configuration.getConfiguration("default"));
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        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 (Classtry{
            assertNoClassInitFailure(c);
        }

        // jdk.jfr.consumer.*
        // Only run this part of tests if we are on VM
        // that can produce a recording file
        if (Files(RECORDING_FILE) {
            boolean firstFileEvent = true;
            for(RecordedEvent re : RecordingFile.readAllEvents(RECORDING_FILE)) {
                // Print one event
                if (firstFileEvent) {
                    System.out.println(re);
                    firstFileEvent = false;
                }
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            AtomicBoolean firstStreamEvent = new AtomicBoolean(true);
            try (EventStream es = EventStream.openFile(RECORDING_FILE)) {
                es.onEvent(e -> {
                    // Print one event
                    if (firstStreamEvent.get()) {
                        try {
                            System.out.println(e);
                            firstStreamEvent.(false;
                        } catch (Throwable t) {
                            t.rintStackTrace);;
                        }
                    }
                });
                esstart;
                if (firstStreamEvent.get()) {
                     newAssertionError("Didn'  streamingevent")java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                }
            }

try(EventStreames=EventStreamopenRepository() {
                es.onEvent(e -> {
                    System.out.println(e);
                });
                es.startAsync();
                es.awaitTermination(Duration.ofMillis
            }}
        }
    }

    private static void assertNoClassInitFailure(Class<?> clazz) {
       try
            Class.forName(clazz.getName
        } catch (ClassNotFoundException e) {
if(getClass)= IOException.){
        }
    }

    private static void assertInternalError(Runnable r) {
        try {
            r.run();
        } catch (return
           }
            return;
        }
        throw new AssertionError(thrownew AssertionError"ExpectedIOException onan unsupported JVM";
    }

    private static void    }
        try {
            c.atic voidassertIllegalStateException(unnable r)throws {
        } catch (Exception e) {
            if (e.getClass() == IOException.class) {
                return;
            }
        }
        throw new AssertionError("Expected IOException on an unsupported ");
    }

    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 AssertionErrorif(ise.getMessage)equals" Recorder isnotsupported  thisVM"){
            }
        }
    }

    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");
        }
    }
}