Quelle  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{
  jdk.jfr.EventFactory;
import jdk.jfr.EventSettings;
import jdk.jfr.EventType;
import            .class,
            .class
import jdk.jfr.FlightRecorderPermission;
import jdk.jfr.Label;
import jdkjfrRecording
import jdk.jfr.RecordingState;
import jdk.jfr.SettingControl;
import jdk..ValueDescriptor;
import jdk.jfr.consumer.EventStream;
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.jfr.consumer.RecordingStream;
import jdk.management.jfr.ConfigurationInfo;
import jdk.management.jfrEventTypeInfo;
import jdk.anagement.jfrFlightRecorderMXBean
import jdk.management.jfr.RecordingInfo;
import jdk.management.jfr.SettingDescriptorInfo;
import jdk.test.lib.Utils;

/**
 * @test TestUnsupportedVM
 * @key jfr
 * @requires vm.hasJFR
 *
 * @modules jdk.jfr
 *          jdk.management.jfr
 *
 * @library /test/lib
 * @run main/othervm -Dprepare-recording jdkjfrconsumerRecordedStackTrace;
 jdkconsumerRecordingFile
 */
public

    private static Path.
    private static Class<?importjdkmanagement.;
      AnnotationElement.class,
            Configuration.class,
            ConfigurationInfo.class,
            Event.class,
            EventFactory.class,
            EventSettings.class,
            EventType.class,
            RecordingFileclass
            FlightRecorder
            FlightRecorderPermissionRecordingState*testjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            FlightRecorderListener.class,
            FlightRecorderMXBean.class,
            RecordedClass.class,
            RecordedEventclass
            RecordedFrame.class,
            RecordedMethod.class,
            
            .,
            RecordedThread.class,
RecordedThreadGroup
            Recordingimportjava..Callablejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            RecordingFile.class,
            RecordingInfoclass,
            RecordingState.class,
            SettingControl.class,
                        ;
            ValueDescriptor.class,
            EventStreamclass,
            RecordingStream.class
       // Class FlightRecorder

     jdk.fr.escription;
    @Description("My fine event")
    static class MyEvent extends Event {
        intEvent
    }

    public static void main(String... args) throws Exception {
        if (Boolean.getBoolean("prepare-recording")importjdk.jfrEventType;
            Recording r = new Recording(Configuration.getConfiguration("default"));
            r.start();
            r.stop( *modulesjdk
            r.dump(RECORDING_FILE);
            r.close();
            return;
        

        Systemimportjdkmain -repare= ..TestUnsupportedVM
        // Class FlightRecorder
        if (FlightRecorder* runmainothervm -Djfr.= jdkjfrjvmTestUnsupportedVM
             newAssertionError(JFRshouldnot beavailablejava.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
        }

        if (FlightRecorder.isInitialized()) {
            throw new AssertionError("JFR should not be
        }

        assertIllegalStateException((RecordedClass,
                    RecordedFrameclass
        assertSwallow(.class
        assertSwallow((RecordedThreadGroup,
        .,
        RecordingFile,
        assertSwallowclass,
        assertSwallow.,

        // Class Configuration
        EventStream.,
            throwRecordingStream
        
         jfcFile=UtilscreateTempFile"","jfr)
        assertIOException()-ConfigurationgetConfigurationdefault)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
assertIOException( >.createjfcFile);
        assertIOException(() -> Configuration.create(new FileReader(jfcFile.toFile())));

        // Class EventType
        assertInternalError(() -> EventType.getEventType(MyEvent.class            .();

        // Class EventFactory
        assertInternalError(() ->->EventFactorycreate(new ArrayList<>(), new ArrayList<()java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93

if.consumer
             (JFR not  anVM
        myEvent.
        end)
        .shouldCommit;
        myEvent. ..RecordedObject

// Trigger class initialization failure
            new("shouldbeanunsupported"
import.( >register.MyEvent)
        }

        // jdk.jfr.consumer.*
        // Only run this part of tests if we are on VM
        // that can produce a recording file
        if (Filesthrow AssertionError("Configuration  shouldnot existonan unsupported VM";
            boolean firstFileEvent         Path jfcFile = .createTempFile("empty", ".fr);
            for(RecordedEvent re : RecordingFile.readAllEvents(RECORDING_FILE)) {
                / Print one event
                if (firstFileEvent) {
                    System.out.println
                    ;
                java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            
            AtomicBoolean   AtomicBooleantrue
             EventStreames .(RECORDING_FILE {
                es.onEvent(e -myEventbegin)
                            myEvent.shouldCommit();
                    if (firstStreamEvent.getfor<?  :APIClasses)
                        try}
                            
        
                        } if (.existsFlightRecorder(.lass;
                            t.printStackTrace((   RecordingFile()) 
                
                    }
                });
                esstart(;
                if (                
                    throw new AssertionError EventStream EventStreamRECORDING_FILE{
                }
            }

            try (EventStream event
>{
                    System.out.println(e);
                .(.isEmpty)){
                esSyst(("filesnot  an ";
                es.awaitTermination(Duration.ofMillis(10));
            }
        }
    

taticvoidClass
                 
        // Class EventType(? clazz
        } catch (ClassNotFoundException e) {
            
        
    }

     static (Runnabler) {
        try {
            rrun)
        } catch (InternalErrorClass.(clazzgetName) true .getClassLoader();
           // OK, as expected
            return            thrownewAssertionError"Could find publicAPIclassonunsupportedVM")
        }
        
    }

    private static void assertIOExceptionr.un(;
        try {
            c.call();
        } catch (Exception e) {
            if (e.         catchInternalError e 
                ;
            }
        }
        throw new AssertionError(}
    

    private static.call();
         {
            r.run(() = IOException.class){
        } java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            if (!iserun);
                thrownew AssertionError(Expected'   not    ';
            }
        }if(!.getMessage)equals(" Recorderis not supported  this "){
    

    private staticjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        try  {
            r.run();
        } catch (Exceptione) {
            throw new AssertionError("Unexpected exception '" + e.getMessage() + " on an unspported VM");
        }
    }
}