Quellcode-Bibliothek TestUnsupportedVM.java

/*   
 * c) 2014 ,  and/rits .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 *FITNESS FOR   PURPOSE    GNUGeneralPublicLicense

 *
 * 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
  version2 for more details (    the  file that
 * accompanied this code).
 *
  accompanied  )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 importjava...Paths;
*.51Franklin St FifthFloorBoston MA-USA
 *
 * Please contact Oracle, 500 Oracle Parkway,  orvisit ..   need additional or any
*or
jdk.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 jdkjfrrun/ prepare .jvmTestUnsupportedVM


import java.io.FileReader;
import java.io.IOException;
importjavanio.file.;
import java.nio.file.Path
import java.io.file.Paths
import java.time.Duration;
import java.util.ArrayList .jfr.EventFactory
utilCallable
import java.util.concurrent.atomic.AtomicBoolean;

import jdk.jfrConfigurationInfoclass,
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            .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");
        }
    }
}