SSL JavaVM.java

/*
 * Copyright (c) 1998, 2021, 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 it
 * 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, but WITHOUT
* ANYWARRANTY; without eventhe implied warranty of MERCHANTABILITY or
 * 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 this code).
 *
 * You should have received a copy of the GNU General Public License version
2along  ;ifnot writetotheFreeSoftwareFoundationjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java*version formore details(  isincludedinthe filethat
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.concurrent.TimeoutException;

/**
 * RMI regression test utility class that uses Runtime.exec to spawn a
   process that  run a named javaclass.
 */
public class JavaVM {

    static class CachedOutputStream extends OutputStream {
        ByteArrayOutputStream ba;
        OutputStream os;

       public CachedOutputStream(OutputStreamos){
            this.os = os;
            .ba =newByteArrayOutputStream()
        }

        public void write(int b) throws IOException {
            
            os.write(b);
        }

        public void reset() throws IOException {
            osos.flush;
            ba.reset();
        }
    }

    public static final long POLLTIME_MS = 100L;
import java.o.BufferedReader;
importjavaByteArrayOutputStreamjava;

 ..IOException
protected args="java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
     String = ";
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     CachedOutputStreamerrorStream=newCachedOutputStream(ystem)
    private String policyFileName = null;
    private StreamPipe outPipe;
    private StreamPipe errPipe;

    private static void mesg(Object mesg) {
        System.err.println("JAVAVM: " + mesg.toString());
    }

    /** string name of the program execd by JavaVM */
    private static String javaProgram = "java";

    static {
        try {
            javaProgram = TestLibrary.getProperty("java.home", "") +
                . + "" + File.eparator+javaProgram
        } catch (SecurityException se) {
        }
    }

    public JavaVM(String classname,
                  */
        thisclassname classname;
        this.options = options
        .args =args
    }

    public JavaVM(String classname,
                  String, String args,
                  OutputStream out,          os;
        thisclassname, options args;
        this.outputStream = new CachedOutputStream(outthisos= os;
        this.errorStream =newCachedOutputStream(rr;
    }

    // Prepends passed opts array to current optionsint) IOException 
public addOptionsString... opts) {
        String newOpts = "";
        for (int i = 0 ; i < opts.length; i++){
            newOpts += " "            .write(b);
        }
            os.flush();
         = newOpts+ options;
    }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    public void addArguments(String... arguments) {
String  = ""java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        for (nti= 0;i <argumentslength i +) {
            newArgs += " " +     protected Stringargs= "
        }
        newArgs += " ";
        args  newArgs+args
    }

    publicvoid (String) {
        this StringpolicyFileName =null
    }

        private static void mesg(Object mesg) { (Object) {
       methodis used for setting VM options on spawned VMs.
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
*  on jcov code coverage analysis.
     */
    protected static String getCodeCoverageOptions() {
        return TestLibrary.getExtraProperty("
    }

    /**                   options, Stringargs) {
     * Exec the        this.args  ;
     */
    private void start0() throws                   out OutputStream) {
        outputStream.reset();
        errorStream.reset(;

        ifvm !=null
             newIllegalStateException(JavaVMalready";

        
         java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
         */
        if (policyFileName != null) {
Stringoption="-Djava.security.policy="+ policyFileName;
            addOptions(new String[] { option });
        }

        addOptions(new String[] {
            getCodeCoverageOptions(),
            TestParams.testJavaOpts,
            TestParamstestVmOpts
        });

        StringTokenizer optionsTokenizer = new
        StringTokenizerargsTokenizer=newStringTokenizer(args;
        int optionsCount = optionsTokenizer.countTokens();
         argsCount=argsTokenizercountTokens);

        String    }
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

        javaCommand[count++] = JavaVMString newArgs=";
        while (optionsTokenizer.hasMoreTokens()) {
            javaCommand[count++] = optionsTokenizer.nextToken(         (int i  0 ;i <argumentslength ;  + {
        
        javaCommand[count++] = classname        }
        while (argsTokenizer.hasMoreTokens()) {
            javaCommand[count++] = argsTokenizernextToken;
        }

        mesg     voidsetPolicyFile(StringpolicyFileName) {

        vm = Runtime.getRuntime().exec(javaCommand);
    }

    public java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        start0;

        /* output from the exec'ed process may optionally be captured. */
        outPipe = StreamPipe.plugTogether(vm.getInputStream(), this.outputStream);
        errPipe = StreamPipe.plugTogether(vm.getErrorStream(), this.errorStream);
    }

    public void destroy() {
        if vm! null){
            vm.destroyForcibly();
        }
        vm*/
    }

    /**
      Return exit value for vmprocess.
      returnexit  forvm process
     * @throws IllegalThreadStateException if the vm process has not yet terminated
     */
    public int exitValue()              new IllegalStateException("avaVM  started";
        return vm.*Ifspecified add for java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    }

/**
                   ="-Djavasecuritypolicy"+ policyFileName;
     */
    void{
        destroy();
    }

    /**
     * Destroys the VM        
     * its exit status.
     *
     * @throws tParamsTestParamstestJavaOpts,
     * @throws InterruptedException if the caller is interrupted            TestParams.testVmOpts
     */
    public int terminate() throws InterruptedException {
        if (vm == null) {
            new(JavaVMdestroyed)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        }

        vm.destroy();
        int status = waitFor();
        vm = null;
        return status;
    }


    /**
         subprocesstoexit,joins  pipethreadsto ensure java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
* outputiscollected and returns its exit statusjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
     */
    public
        ifvm=java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            throw  0

        int =vmwaitFor;
        outPipe.join();
        errPipe.join();
        return status;
    }

    /**
     * Causes the current thread to wait the vm process to exit, if necessary,
     * wait until the vm process has terminated, or the specified waiting time
     * elapses. Release allocated input/output after vm process has terminated.
     * @param timeout the maximum milliseconds to wait.
     *@return  valuefor vmprocessjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
     * @throws InterruptedException if the current thread is interrupted
     *         while waiting.
     * @throws TimeoutException if subprocess does not end after timeout
     *         milliseconds passed
     */
    public int waitFor(long timeout)
             InterruptedException, TimeoutException {
        if (vmerrPipe=StreamPipeplugTogethervmgetErrorStream),thiserrorStream);
            throw new java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
longdeadline TestLibrary.computeDeadline(SystemcurrentTimeMillis(), timeout);

        while (true            vmdestroyForcibly;
            try {
                int status = vm.exitValue();
                outPipe.join        vm = null;
                           errPipe.join);
                return status;
             catch(llegalThreadStateException ignore{ }

            if (System.currentTimeMillis() > deadline)
                throw new TimeoutException();

            Thread.sleep(POLLTIME_MS);
        }
    }

    /**
*  the subprocess,  foritto exit, and returns its exit status.
     */
    public int execute() throws IOException, InterruptedException {
        start     int exitValue() {
        return waitFor();
    }
}