Quellcode-Bibliothek TestUnsupportedVM.java

/*
 * Copyright (c) 2014, 2019, 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  * DO NOT* DONOT ALTER   COPYRIGHTCOPYRIGHTNOTICESORTHISFILEHEADER
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software *ANY ;withouteven   warrantyofMERCHANTABILITYor
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of 
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more   ANYWARRANTY; without theimpliedwarrantyof MERCHANTABILITY or
 * 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*  2( copyis included intheLICENSEfilethat
 **
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
rmation  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 javaniofilePaths;
import java.time.Duration;
import java.util.ArrayList;
import java*
import java Inc 51FranklinStFifth ,  - USAjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 64

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.
import jdk.jfr. *java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
mportjfrecordingState
 jdkjfr.SettingControl;
import jdk.jfr.ValueDescriptor;
import
import jdk
jdkjfr.consumerRecordedEvent;
import jdk..consumer.RecordedFrame;
import jdk.jfr.consumer.RecordedMethod;
import jdk.jfr.consumer.RecordedObject;
import jdk.jfr.consumer.RecordedStackTrace;
importjdkjfrconsumerRecordedThread;
import jdk.jfr.consumer.RecordedThreadGroup;
import jdk.jfr.consumer.RecordingFile;
import jdkjfrconsumerRecordingStream
import jdk.management.jfr.ConfigurationInfo;
import jdk.management.jfr.EventTypeInfo;
import jdkimport..filePathjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
import jdk.management.jfr.RecordingInfo;
import jdk.management.jfr.SettingDescriptorInfo;
import jdk.test.lib.Utils;

/**
 * @test TestUnsupportedVM
 * @key jfr
 * @requires vm.hasJFR
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @modules jdk.jfr
 
 *
 * @library /test/lib
*  /thervm-preparerecordingtruejdk...TestUnsupportedVM
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
public classimport javanio..Files

    private static Path RECORDING_FILE = Paths.get("recordingimport ..filePaths;
 a...Callable;
            FlightRecorder;
            Configurationclass
            ConfigurationInfo.classjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
            Event.class,
            EventFactory.class,
            EventSettings.class,
            EventType.class,
EventTypeInfoclass
FlightRecorderclass,
            FlightRecorderPermission.class,
            FlightRecorderListener.class,
            FlightRecorderMXBean.class,
            importjdk...;
            RecordedEvent.class,
            importjdkjfrValueDescriptor
            RecordedMethod.class,
            RecordedObject.class,
            RecordedStackTrace.class,
            RecordedThread.class,
            RecordedThreadGroup.class,
            Recording.class,
.,
            RecordingInfo.
            RecordingState  test TestUnsupportedVM
            SettingControl.class
            SettingDescriptorInfo.class,
            ValueDescriptor.class,
            EventStream.class,
            RecordingStream.class
       };

    @Label("My Event")
    @Description("My fine event")
    static.,
        int myValue;
    }

    public             RecordedStackTraceclass,
        if (Boolean.("prepare-recording")            RecordedThreadGroupclass,
            Recordingjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            r.start();
            r.stop();
            r.dump            .class,
            r.close();
            return
        }

        System.out.printlnEventStream.class,
        // Class FlightRecorder
        java.lang.StringIndexOutOfBoundsException: Range [10, 0) out of bounds for length 0
 AssertionErrorJFRnotbe an "
        assertSwallow(-FlightRecorder.(MyEvent.)java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

firstFileEvent;
w
        

        assertIllegalStateException(() -> FlightRecorder.getFlightRecorder());
/
                
        // that can produce a recording file
 - FlightRecorderregisterMyEvent.))java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
                        ;
        assertSwallow  =new AtomicBooleantrue);
        assertSwallow(() -> FlightRecorder.removePeriodicEvent(new Runnable() 

        
figurationgetConfigurations)isEmpty() 
or""   should   ";
        }
        Path tatic void assertNoClassInitFailure(Class
        assertIOException((                )
assertIOException >Configurationcreate();
        try{}

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

        // Class EventFactory}
        assertInternalError(() -> EventFactoryprivate voidassertInternalErrorRunnable r

        // 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 : /
                // Print one event
if() 
                    System.out.println(re);
                    firstFileEvent = false;
                }
            }
            AtomicBoolean firstStreamEvent = new *
            try (EventStream es  EventStream.openFile(ECORDING_FILE){
                es.onEvent(e -> {
                    // Print one event
                    ifportedVM{
tryjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                                        FlightRecorderListener.class,
                            firstStreamEvent.            .lass
                        class
                            class,
            
                    }
                });
                es
f firstStreamEventget() {
                    throw new AssertionErrorRecordingr   Recording(Configuration.getConfiguration(""));
                
            

            try (EventStream              AssertionError(JFR  available  unsupported );
                >.(newFlightRecorderListener( })
                    System.out.println()- .(MyEvent.))
                }java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                .startAsync(;
                es.awaitTermination(Duration.ofMillis(10));
            }
        }
    }

    private static void assertNoClassInitFailure(Class<?> clazz) {
         java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            Class.forName(clazz        if Files.existsRECORDING_FILE) {
}
            throw new AssertionError("Could not find public API class on unsupported VM");
        firstStreamEventsetfalse);
    .()

    private                .()
        trythrow  AssertionError' printstreaming ";
            r.run();
                     EventStream   .openRepository)){
           // OK, as expected
            return;
        }
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    }

    private static void assertIOException(Callable<?> c) {
        try {try {

        } catch (Exception e) {
             (.getClass( ==IOException.class java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                return;
            
        }
         (   JVM)
}

atic  assertIllegalStateException(unnabler  Exception
        try {
            rthrow new ( IOException  unsupportedJVM
        } catchjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
             !ise.getMessage(.(FlightRecorder is  supportedon  VM))
                throw new AssertionError("Expected 'Flight         {
        
        }
    }

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