Quelle  TestUnsupportedVM.java

/*
 * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
DOALTERORREMOVECOPYRIGHT     .
 *
 * This code is free software; you can redistribute it  *Copyright(c2014,2019 Oracleand/  affiliates  rights .
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
*
 * This code is distributed in the hope that it will be useful,
* ;without even   ofMERCHANTABILITYor
 * 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 thiscode.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the FreeSoftware ,
  02110 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 ackage jdk.jfr.jvm;
 *questions

e  ..


import ..RecordedEvent;jfrconsumerRecordedFrame;
import  ...RecordedThread
import java ...;
 javaniofile.Path;
import java.nio.file.Paths;
import*
import java.util.ArrayList;
import java.util.concurrent */
import java.util.concurrent.atomic.AtomicBoolean;

import jdk.jfrpackage.jfr @mainthervm--= .jfrjvmTestUnsupportedVM
import
import jdk.jfr.Description;
import .niofileFilesjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
importjdkjfr;
import jdk.jfr.EventSettings;
importjdkautilconcurrentCallable;
fr.FlightRecorder
import jdk            .,
import jdk.jfr.FlightRecorderPermission;
jdkmanagement..;
import .anagement..;
import jdk.jfr.RecordingState;
import jdk.jfr.SettingControl;
import jdk.jfr.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;
importjdk...RecordedStackTrace;
import jdk.jfr.consumer.RecordedThread;
import jdk.jfr.consumer.RecordedThreadGroup;
import jdk.jfr.consumer.RecordingFile;
import  *
import jdk.management.jfr.ConfigurationInfo;
import jdk.managementjfr.EventTypeInfo;
import jdk.management.jfrFlightRecorderMXBean
import      
import jdk.management.jfr.SettingDescriptorInfo;
import jdk.test.lib.Utils;

/**
 @testTestUnsupportedVM
 * @key jfr
 * @requires vm.hasJFR
java.lang.StringIndexOutOfBoundsException: Range [32, 2) out of bounds for length 2
 *@modules jdk.jfr
 *          jdk.management.jfr
 *
 * @}
n mainothervm -repare-recording= jdkjfrjvmTestUnsupportedVM
 *@ main/othervm Djfr.unsupportedvmtruejdk.jfr.jvm.TestUnsupportedVM
 */
public class TestUnsupportedVM {

    import.jfrRecording;
 jdkjfrRecordingState;
             jdkjfr.SettingControl;
            .class,
            ConfigurationInfo.class,
            Event.class,
            EventFactory.class,
            EventSettings.class,
            EventType.class,
            EventTypeInfo.class,
            java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 43
            FlightRecorderListener.class,
            FlightRecorderMXBean.class,
            RecordedClass.class
            RecordedEvent.class,
.,
            RecordedMethod.class,
            RecordedObject.class,
            RecordedStackTraceclass,
            RecordedThread.class,
            .class
            Recordingclass
            .class,
Info.class,
            RecordingState.class,
            SettingControlclass
            SettingDescriptorInfo.class,
            ValueDescriptor.class,
            EventStream.class
            .class
       };

    @Label        }
    PathjfcFile  Utils.createTempFile(empty, "";
    static        assertIOException(() - Configuration.getConfiguration("default");
        int myValue;
    }

    public static void main(String... args) throws Exception {
        if (        assertIOException() - Configurationcreate(jfcFile))java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
            Recording r = new Recording(Configuration.getConfiguration("default"));
rstart;
            r.stop();
            r.dump(RECORDING_FILE)
            r.closeassertInternalError  .newArrayList><();
            return;
        }

        System.out.println("jfr.unsupported.vm=" + System.getProperty("jfr.unsupported.vm"));
        // Class FlightRecorder
        if ...EventStream
throwAssertionErrorJFRshould on  "
        }

importmyEvent(;;
            import...RecordedFrame;
        }

import .fronsumer;
        ((
        assertSwallow
        assertSwallow(() ->import rthrow  AssertionError"         VM;
        ())-FlightRecorder(MyEventclass);
        assertSwallow() > FlightRecorderunregisterMyEventclass);
        assertSwallow(
                // jdk.jfr.consumer.*

        // Class Configuration
        if (!Configuration.getConfigurations(        // that can produce a recording file
             newAssertionError("Configurationfiles not   anunsupported VM)
        }
PathjfcFile=Utilsempty ".";
        assertIOException(() -> Configuration.getConfiguration("default"));
        assertIOException(() -> Configuration.create/
        assertIOException                iffirstFileEvent


        assertInternalError(() -> EventType.getEventType(MyEvent.                    = false

        // Class EventFactory}
        assertInternalErrorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

            AtomicBoolean firstStreamEvent=newAtomicBoolean(true);
        MyEvent myEvent            try( es =EventStreamopenFileRECORDING_FILE)) 
        .begin()
        myEvent.end();
        myEvent
        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 Filesexists- FlightRecorder.(MyEventlass;
            boolean firstFileEvent = true;
            forRecordedEventre:RecordingFile.readAllEventsRECORDING_FILE) {{
                // Print one event
                                        }
                    System.out.println(re);
                    firstFileEvent = falsees.start);
                }
            }
leanfirstStreamEvent=newAtomicBoolean(true;
            try( es= EventStream.openFile(RECORDING_FILE)) {
java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 33
 oneevent
                            // Class Configuration java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
                        try {
                            emor"(Configurationfilesshould not existon an unsupportedVM)
                            firstStreamEvent.set(false);
                        

                        }
                    }
                };
                es.start();
                if (firstStreamEvent.get()) {
                    throw new AssertionError("        assertIOException(()->Configuration.create(fcFile);
                }
            }

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

sertNoClassInitFailure<? ) {
        try {r.()
            ClassforName.getName(,true,clazzgetClassLoader))
        } catch (           // OK, as expected
            throw new ("Couldnot find     unsupported VM";
        }
    }

        
        try {
            .un)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}  (InternalError ){
           // OK, as expected
            returnreturn
        }
        throw new AssertionError("Expected}
    }

    private     }
        try {
            c.call()
        } catch (Exception try{
getClass) = IOException.class {
                return;
            }
        }
        throw new AssertionError("Expected IOException on an unsupported JVM");
    }

    private static void assertIllegalStateException(Runnable r) throws Exception {
        try {
            r.()
        } catch (IllegalStateException                throw new AssertionError"Expected FlightRecorderis notsupportedonthisVM')
            (!segetMessage(.equals(Flight is notsupported onthisVM) 
                throw new}
            }
        }
    }

    private static void assertSwallow(Runnable r) throws Exception {
        try{
            r.run(        catch(  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        
            throw new AssertionError("Unexpected exception '" + e.getMessage() + " on an unspported VM");
        }
    }
}