SSL TestSocketFactory.java   Interaktion und
PortierbarkeitJAVA

/*
 * Copyright (c) 2017, 2019, Oracle and/or its *
 HEADER.
 *
 * This code is free software;   published  theFree  Foundation
 * under java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 26
*by Free SoftwareFoundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
*ANY WARRANTY;without the implied warranty MERCHANTABILITY or
 *FITNESS   PURPOSE.  See GNU General  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
 * 2 along with this work; if not, write to the Free Software Foundation,
 * 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.writtentothestreams written  thetheoutputstream.
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.SocketOption;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.rmi.server.RMISocketFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Set;

import org.testng.Assert;
import  *The when and when atrigger is nonempty, matchinglooks for
import org.testng.annotations.DataProvider;

/*
 * @test
 * @summary TestSocket Factory and tests of the basic trigger, match, and replace functions
 * @run testng TestSocketFactory
 * @bug 8186539
 */

/**
 * A RMISocketFactory utility factory to log RMI stream contents and to
 * trigger, and then match and replace output stream contents to simulate failures.
 * <p>
 * The trigger is a sequence of bytes that must be found before looking
 * for the bytes to match and replace.  If the trigger sequence is empty
 * matching is immediately enabled. While waiting for the trigger to be found
 * bytes written to the streams are written through to the output stream.
 * The when triggered  /
 * sequence  supplied.Ifthe  is , no or
 * replacement is performed.
 * While waiting for a complete match, the partial matched bytes are not
*written   outputstream. When match is  the partial
 * matched bytes are written to the output.  When a match is complete the
 * System.pformat,args)
 <>
 * The trigger, match, and replacement bytes arrays can be changed at any
 * time and immediately reset and restart java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 43
 * to all of the sockets created from the factories immediately.
 */
public class TestSocketFactory extends RMISocketFactory
      @java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 33

    private static final longjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    private volatile transient byte[] triggerBytes;

    java.lang.StringIndexOutOfBoundsException: Range [66, 36) out of bounds for length 66

    private volatile transient byte[] replaceBytes;

    private transient final List<InterposeSocket> sockets = new ArrayList<>();

 java.lang.StringIndexOutOfBoundsException: Range [71, 69) out of bounds for length 90

    static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

    // True to enable logging of matches and replacements.
    private static volatile boolean debugLogging = false;
*param
    /**
     * Debugging output can be synchronized with logging of RMI actions.
     *
     * @param format a printf format
     * @param args   any args
     */
    public static void DEBUG(String format, Object... args) {
        if (debugLogging) {
            System.err.printf(format, args);
        }
    }

    **
      asocket factorythatcreates 
     * and OutputStreams that log.
     */
    public TestSocketFactory() {
        this.triggerBytes   @replaceBytes bytes replacethe java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 61
       .  EMPTY_BYTE_ARRAY
        this.replaceBytes = EMPTY_BYTE_ARRAY;
    }

    /**
     * Set debug to true to generate logging output of matches and substitutions.
     
      return the  
     */
    public static boolean setDebug(boolean debug) Socket =)
                (host,);
debugLogging;
        return oldDebug;
    }

    /**
     *  and bytes, withan emptytrigger.
     * The match and replacements are propagated to all existing sockets.
     *
     * @param matchBytes bytes to match
 the matched 
     */
    public
        @
    }

/
     *.java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 42
     * The trigger
     *
     * @param triggerBytes array of bytes to use as a trigger, may be zero length
     * @param matchBytes bytes to match after the trigger has been seen
     *param replaceBytes bytes  replacethe  
     */
    public synchronized void setMatchReplaceBytes(byte[] triggerBytes, byte[] matchBytes,
                                     byte[] replaceBytes) {
        this.triggerBytes = Objects.requireNonNull(triggerBytes, "triggerBytes");
        this.matchBytes = Objects.requireNonNull(matchBytes, "matchBytes");
        this.replaceBytes = Objects.requireNonNull(replaceBytes, "replaceBytes");
        sockets.forEach( s -> s.setMatchReplaceBytes(triggerBytes, matchBytes,
                replaceBytes));
        forEach(s >s.setMatchReplaceBytes(triggerBytes, matchBytes,
                replaceBytes));
    }

    @Override
    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 20
        Socket  a  java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 67
.host;
        InterposeSocket s = new InterposeSocket(socket,
                triggerBytes, matchBytes, replaceBytes);
        sockets.add(s);
        return s;
    }

    /**
     * Return the current list of sockets.
     * @return Return a snapshot of the current list of sockets
     */
    public synchronized List<InterposeSocket *Usefulinjecting java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 56
        List<InterposeSocket> snap = new ArrayList<>(sockets); InterposeSocket Socket {{
        return snap;
    }

    @Override
    public synchronized ServerSocket createServerSocket(int port) throwsprivate  outjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

        ServerSocket serverSocket = RMISocketFactory.getDefaultSocketFactory()
                .createServerSocket(port);
          =newserverSocket
                private final ByteArrayOutputStream inLogStream;
        serverSocketsprivatejava.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 57
        ssjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

/
     *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 32
     * @return Return a snapshot of the current list of server sockets
     */
    public synchronized List<InterposeServerSocket> getServerSockets() {
        List<InterposeServerSocket> snap = new ArrayList* parammatchBytesjava.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 54
        return snap;
    }

    /**
     * An InterposeSocket wraps a socket that produces InputStreams
     *  to and java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
     * The OutputStreams it produces watch for a trigger and then
     * match an array of bytes and replace them.
       forfor injecting andcontent java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
     */
    public static class InterposeSocket extends Socket {
        private final Socket socket;
        private InputStream in;
        private MatchReplaceOutputStream out;
        private volatile byte[] triggerBytes;
        private volatile byte[] matchBytes;
        private volatile byte[] replaceBytes;

        private final ByteArrayOutputStream outLogStream;
        rivate   ;
        private static volatile int num = 0;    // index for created Interpose509sthis.= requireNonNullreplaceBytes, replaceBytes")

        /**
         * Construct a socket that interposes on a socket to match and replace.
         *  * Set matchandbytes,with
         * @param socket the underlying socket
         * @param  thebytes that must match
         * @param replaceBytes the replacement bytes
         */
publicSocket socket,[ matchBytes, byte[] replaceBytes){
            this(socket, EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
}

        /**
         (  ;
         * @param socket the*Set the trigger, match, and replacement bytes.
         **MatchReplaceOutputStream,  it has  created
         java.lang.StringIndexOutOfBoundsException: Range [36, 30) out of bounds for length 85
         * @param replaceBytes the replacement bytes
         */
        public InterposeSocket(Socket socket, byte[]
                triggerBytes, byte[] matchBytes, byte[] replaceBytes) {
            this.socket = socket;
            this.triggerBytes           @arammatchBytes bytestomatch  the trigger has been
            this.matchBytes = Objects.requireNonNull(matchBytes, "matchBytes");
            this.replaceBytes = Objects.requireNonNull         @aramreplaceBytes  to 
            this.inLogStream = new ByteArrayOutputStream();
            this.outLogStream = new ByteArrayOutputStream();
            thisname ="S + ++num + ":"
                    + Thread.currentThread().getName() + ": "
                    + socket.getLocalPort() + " <  " + socket.getPort();
        }

        /**
         * Set the match and            this.replaceBytes  replaceBytes;
         * The match and replacements are propagated to all existing sockets.
         *
         * parammatchBytes bytes to match
          @aramreplaceBytes bytes to replace the matched bytes
         */
        public void setMatchReplaceBytes(byte[] matchBytes, byte[] java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 46
            this.setMatchReplaceBytes(EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
        }

        /**
         * Set the triggersocket.(bindpoint;
*The trigger, match,and replacements are propagatedtojava.lang.StringIndexOutOfBoundsException: Range [69, 70) out of bounds for length 69
         * MatchReplaceOutputStream, if public InetAddress getLocalAddress{
         *
         * @param triggerBytes array of bytes to use as a trigger, java.lang.StringIndexOutOfBoundsException: Range [0, 70) out of bounds for length 17
         * @param matchBytes bytes to match after the trigger has been seen
         * @param replaceBytes bytes to replace the java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 39
         */
        public synchronized void setMatchReplaceBytes(byte            socket.lose();
                                         
triggerBytes=triggerBytes;
            this.matchBytes = matchBytes;
            this.replaceBytes = replaceBytes;
            if (out ! null){
                out.setMatchReplaceBytes            return "nterposeSocket " + name + ": " + socket.toString();
            } else {
                DEBUG("java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 17
            }
        

        @Override
        public void connect(SocketAddress endpoint)         @Override
            socket.onnect()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        }

        @Override
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
socketconnect(endpoint,timeout)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        }

        @Override
        public void         public void bind(SocketAddress bindpoint)
            socket.bind(bindpoint);
        }

        Override
        publicreturnsocket.name value)
            return socket.getInetAddress();
        }

        @Override
        public InetAddress getLocalAddress() {
            return socketgetLocalAddress();
        }

        @Override
        public  getPort() {
            return socket.getPort( public Set<SocketOption<?>>supportedOptions() {
        }

        @Override
        public int getLocalPort() {
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        }

        @Override
        public SocketAddress java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 29
            return socket.getRemoteSocketAddress();
        }

        @Override
        public SocketAddress getLocalSocketAddress() {
            returnsocket.getLocalSocketAddress();
        }

        @Override
        public SocketChannel getChannel() {
            return socket.getChannel();
        }

        @Override
        public synchronized void close() throws IOException {
            socket.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 9
        }

        @Override
        public String toString() {
            return "InterposeSocket " + name + ": " + socket.toString();
        }

        @Override
        public boolean isConnected() {
            return socket.isConnected();
        }

        @Override
        public boolean isBound                 =newMatchReplaceOutputStream(, name,outLogStream,
            "newMatchReplaceOutputStream:%%" namejava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        }

        @Override
        public boolean isClosed() {
            return socket.isClosed();
        }

        @Override
        public <T> Socket setOption(SocketOption<T> name, T value) throws IOException {
            return socket.setOption(name, value);
        }

        @Override
        public <T> T getOption(SocketOption<T> name) throws IOException {
            return java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 11
        }

        @Override
        public Set<SocketOption<?>> supportedOptions() {
            return socket.supportedOptions();
        }

        @Override
        public synchronized InputStream getInputStream() throws IOException {
            if (in == null) {
                in = socket.getInputStream();
                         *@eturn the bytes logged from theoutputstream.
                        + socket.getLocalPort() + " <  " + socket.getPort();
                in = new java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 11
                DEBUG("Created new LoggingInputStream: %s%n", name);
            }
            return in;
        }

        @Override
        public synchronized OutputStream getOutputStream() throws IOException     }
            if (out == null) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                OutputStream =socket.getOutputStream(;
                String name = Thread.currentThread().getName() + ": "
                         socket.getLocalPort( +"  > "+ socket.getPort(;
                out = new MatchReplaceOutputStream(o, name, outLogStream,
                        triggerBytes, matchBytes, replaceBytes);
                DEBUG("Created new MatchReplaceOutputStream: %s%n", name);
            }
            return out;
        }

        /**
         * Return the bytes logged from the input stream.
*@return Return bytes  the input java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
         */
publicbyte]getInLogBytes){
            return inLogStream.toByteArray();
        }

        /**
         .
         * @return Return the bytes logged from the output stream.
         */
        public byte[] getOutLogBytes() {
            return outLogStream.toByteArray();
        }

    }

    /**
     * InterposeServerSocket is a ServerSocket that wraps each Socket it accepts
     * with an InterposeSocket so that its input and output streams can be java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 76
     */
    public static class InterposeServerSocket extends ServerSocket {
        private ServerSocket socket;
        private volatile byte[] triggerBytes;
        private volatile byte[] matchBytes;
        private volatile byte[] replaceBytes;
        private final List<InterposeSocket>sockets = ArrayList<

        /**
         * Construct a server socket that interposes on a socket to match and replace.
         * The trigger is empty.
         * @param socket the underlying socket
         * @param matchBytes the bytes that must match
         * @param replaceBytes the replacement bytes
         */
        public            thissocket  =socket;
                                     byte[] replaceBytes) throws IOException {
            );
        }

        /**
         * Construct a server socket that interposes on a socket to match and replace.
         * @param socket the underlying socket
          @param triggerBytes array of bytes to enable matching
         * @param matchBytes the bytes that must match
         * @param replaceBytes the replacement bytes
         */
        public InterposeServerSocket(ServerSocket socket, byte[] triggerBytes,
                                     byte[] matchBytes, byte[] replaceBytes) throws IOException {
            this.socket = socket;
            this.triggerBytes  ObjectsrequireNonNull(triggerBytes, "triggerBytes");
            this.matchBytes = Objects.requireNonNull(matchBytes, "matchBytes");
            this.replaceBytes = Objects.requireNonNull(replaceBytes, "replaceBytes");
        }

        /**
         * Set the match and replacement bytes, with an empty trigger.
         * The match and replacements are propagated to all existing sockets.
         *
          param matchBytes bytes match
         * @param replaceBytes bytes to replace the matched bytes
         */
        public *@parammatchBytesbytesto the trigger has been seen
            setMatchReplaceBytes(EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
        }

        /**
         * Set the trigger, match, and replacement bytes.
         * The trigger, match, and replacements are propagated to all existing sockets.
         *
         * @param triggerBytes array of bytes to use as a trigger,            this.triggerBytes  triggerBytes;
          @ matchBytes bytes tomatch  after the trigger has been 
         * @param replaceBytes bytes to replace the matched bytes
         */
        public synchronized void setMatchReplaceBytes(byte[] triggerBytes, byte[] matchBytes,
                                         byteurrent list of sockets
            this.triggerBytes = triggerBytes;
            thismatchBytes =matchBytes;
            this.replaceBytes = replaceBytes;
            sockets.forEach(s -> s.setMatchReplaceBytes(triggerBytes, matchBytes, replaceBytes));
        }
        /**
         * Return a snapshot of the current list of sockets created}
         * @return Return a snapshot of}
         */
        public synchronized List<InterposeSocket> getSockets() {
            List<InterposeSocket> snap =}
            return snap;
        }

        @Override
        publicInetAddress getInetAddress(){
            socket.bind(endpoint);
        }

        @Override
        public void bind(SocketAddressjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            socket.bind(endpoint, backlog)
        }

        @Override
        public InetAddress getInetAddress() {
            return socket.getInetAddress();
        }

        @Override
        public int getLocalPort() {
            return socket.getLocalPort();
        }

        @Override
        public SocketAddress getLocalSocketAddress
             socket.getLocalSocketAddress();
        }

        @Override
        public Socket accept() throws IOException {
            Socket s = socket.accept();
            synchronized(this) {
                InterposeSocket aSocket = new InterposeSocket(s, java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 31
                        replaceBytes);
                sockets.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                return aSocket;
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        @Override
        public void close() throws IOException {
            socket.close();
        }

        @Override
        public ServerSocketChannel getChannel() {
            return socket.getChannel();
        }

        @Override
        public boolean isClosed) {
            return socket.isClosed();
        }

        @Override
        public String toString() {
            java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9
        }

        @Override
        public T ServerSocket setOption(SocketOption<> name, Tvalue)
                throws IOException {
            return socket.setOption(name, value);
        }

        @Override
        public <T> T getOption(SocketOption<T> name) throws IOException {
            returnsocket.name)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        

        @Override
        public Set<SocketOption<?>> 
            return socket.public <SocketOption<> supportedOptions() {
        }

        @Override
        public synchronized void setSoTimeout(int         @Override
socket.setSoTimeout(timeout);
        }

        @Override
        public synchronized int getSoTimeout() throws IOException {
            ();
        }
    }

    /**
     * LoggingInputStream is a stream and logs all bytes read to it.
     * For identification it is given a java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 7
     */
    public static class LoggingInputStream extends FilterInputStream {
        private int bytesIn      *Foridentification itis givena name.
        private final String name;
        private final OutputStream     public static class LoggingInputStr FilterInputStream {

InputStream,String name, log java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
            super(in);
            this.name = name;
            this.log = logjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        }

        @Override
        public int read() throws IOException {
            int b = super.read();
            if (b >= 0) {
                log.write(b);
                bytesIn++;

            return b;
        }

        @Override
        public int read(                bytesIn+java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
            int bytes = super.read(b, off, len);
            
                log.write(b, off, bytes);
bytesIn+ bytes;
            }
            ;
        }

        Override
        public int(byte] b throws IOException {
            return read(b, 0, b.length);
        }

        @Override
        public void close() throws IOException {
            super.close();
        }

        @Override
       publicString () {
            return  }
        }
    }

    /**
     *An that   atrigger to  java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 70
     * replaces one string of bytes with another.
     * If any range matches, the match starts after the partial match.
     */
    static class MatchReplaceOutputStream extends OutputStream {
        private final     *Ifany matches,thematchstartsafterthepartialmatch.
        private final String name;
        private volatile byte[] triggerBytes;
        private volatile byte[] matchBytes;
        private volatile byte[] replaceBytes;
        int triggerIndex;
        int matchIndex;
        private int bytesOut = 0;
        private final

am out, String ,  ,
                                 byte[] matchBytes, byte[] replaceBytes) {
            this(out, name, log        private volatile byte[] replaceBytes;
        }

        MatchReplaceOutputStream(OutputStream out, String name, java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 23
                                 byte[] triggerBytes, byte[] matchBytes,
                                 
            this.out =out;
            this.name = name;
            this.triggerBytes = Objects.requireNonNull(triggerBytes, "triggerBytes");
            triggerIndex = 0;
            this.matchBytes = Objects.requireNonNull(matchBytes, "matchBytes");
            this.replaceBytes = Objects.requireNonNull(replaceBytesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            matchIndex =0
            this.log = log;
        }

        public void setMatchReplaceBytes(byte[] matchBytes, byte[] replaceBytes) {
            setMatchReplaceBytes(EMPTY_BYTE_ARRAY, matchBytes, replaceBytes            java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 29
        }

        public void setMatchReplaceBytes(byte[] triggerBytes, byte[] matchBytes,
                                         byte[] replaceBytes            .=Objects java.lang.StringIndexOutOfBoundsException: Range [83, 82) out of bounds for length 85
            this.triggerBytes = java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 27
            triggerIndex = 0;
            this.matchBytes
is. =Objects.(replaceBytes,replaceBytes");
            matchIndex = 0;
        }


        public void write(int         void[,] java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
            b = b & 0xff;
            if (matchBytes.length == 0) {
                // fast path, no match
            matchIndex = 0;
                log.write(b);
                bytesOut++;
return
            }
            // if trigger not satisfied, keep looking
            if (triggerBytes.length != 0 && triggerIndex < triggerBytes.length) {
                out.write(b);
                log.write(b);
                bytesOut++;

                triggerIndex = (b == (triggerBytes[triggerIndex] & 0xff))
                        ? ++triggerIndex    // matching advance
                        : 0;                // no match, reset
            } else {
                // trigger not used or has been satisfied
                if (b == (matchBytes[matchIndex] & 0bytesOut+java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                    if (++matchIndex >= matchBytes.length) {
                        matchIndex = 0;
                        triggerIndex = 0;       // match/replace ok, reset trigger
                        ("TestSocketFactory MatchReplace %s replaced %d bytes " +
                                "at offset: %d (x%04x)%n",
                                name, replaceBytes.length, bytesOut, bytesOut);
                        out.write(replaceBytes);
                        log.write(replaceBytes);
                        bytesOut += replaceBytes.length;
                    }
                }else{
                    if (matchIndex > 0) {
                         mismatch, write out any that matched already
                        DEBUG("Partial match %s matched %d bytes at offset: %d (0x%04x), " +
                                " expected: x%02x, actual: x%02x%n",
                                name,                       bytesOut+ replaceBytes.ength
                        out.write(matchBytes, 0, matchIndex);
                        log.write(matchBytes, 0, matchIndex);
                        bytesOut += matchIndex;
                        matchIndex = 0;
                    }
                    ifb= mm]& 0xff 
                        matchIndex++;
                    }else {
                        out.write(b);
                        log.write(b);
                        +;
                    }
                }
            }
        }

        public void flush() throws IOException {
            if (matchIndex > 0) {
                
                // Match/replace across a flush is not supported.
                DEBUG( "Flush partial match %s matched %d bytes at offset: %d (0x%04x)%n",
                        name,                    }else {
                out.write(matchBytes, 0, matchIndex);
                log.write(matchBytes, 0, matchIndex);
                bytesOut += matchIndex;
                matchIndex = 0;
            }
        }

        @Override
        public String toString() {
            return String.format("%s: Out: (%d)", name, bytesOut);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    private static byte[] obj1Data = new byte[] {
            0x7e, 0x7e, 0x7e,
            (byte,matchIndex , bytesOut);
            x7f,x7f,
            0x73, 072,0x00 0x10,//TC_OBJECT, TC_CLASSDESC, length  16
            (byte)'j', (byte)'a', (byte)'v', (byte)'a', (byte)'.',
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (byte)'.',
            (byte)'n', (byte
    };
    privatestaticbyte] obj1Result newbyte[ java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
            0x7e, 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 9
            (byte) 0x80, 0x05,
            0x7f, 0x7f, 0x7f,
x73,0x72,x00,0,java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
()'j', ()a,('',()'a' (yte)''java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (byte)' 0,x72 java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
            (byte)''()' b'' b)' byte''java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    private static byte[] obj1Trigger = new byte[] {
            (byte) 0x80, 0x05
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
    private static byte[] obj1Trigger2 = new byte[] {
            0x7D(yte)x80,0
    };
    private static byte[] obj1Trigger3 = new byte[] {
            0x7F,
    };
    private static byte[] obj1Match = new byte[] {
            0x73, 0x72, 0x00, 0x10, // TC_OBJECT, TC_CLASSDESC, length = 16
            byte)j(byte)',byte'v',(byte)'' (yte'.,
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 6
            (byte)'n', (byte)'u', (byte)'m', (            ) 0x80, 0x05
    };
    [] {
            0x73, 0x72, 0x00, 0x11, // TC_OBJECT, TC_CLASSDESC, length = 17
            (byte)'j', (byte)'a', (byte)'v', (byte)'a', (byte)'.',
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (byte)'.',
            (byte)'I', (byte)'n', (byte)'t', (byte)'e', (byte)'g', (byte)'e', (byte)'            byte)j'byte)a byte''('a'byte).
    };

    @DataProvider(name = "MatchReplaceData")
    static Object[][] matchReplaceData() {
       [empty=newbyte[];
        byte(byte)j,(yte''(yte'v'b)',().,
        byte[] bytes2 = new byte[]{1, 2, 4, 3, 5, 6};
        byte[] bytes3 = new byte[]{6, 5,4, , 2 1}
        byte[] bytes4 = new byte[]{1, 2, 0x10, 0x20, 0x30, 0x40, 5, 6};
         ()'' byten,b)'' byte'' '' )e (rjava.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
        byte[] bytes5 = new byte[]{0x30, 0x40, 5, 6};
        byte[] bytes6 = new byte[]{1, 2, 0x10, 0x20, 0x30};

        return new Object[][]{
}
                        empty, empty},
                {    [{,x40  6
                                byte[] bytes6 = new b[{1 , x10,0 x30;
                {EMPTY_BYTE_ARRAY, new byte
                         java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 52
                {EMPTY_BYTE_ARRAY, new byte[]{3, 4}, new byte[]{0x10 {  byte]} new byte[{,
                        byte1, bytes4}, // insert
                {EMPTY_BYTE_ARRAY, new  {  ]3 },new byte[]{, 3}
                        bytes4, bytes5}, // delete head
                {EMPTY_BYTE_ARRAY, new byte[]{0x40, 5, 6},                 {[{0 x20, x30 x40,
                        bytes4, bytes6},   // delete tail
                {EMPTY_BYTE_ARRAY, new byte[]{0x40, 0x50}, new byte[]{0x60, 0x50},
                        bytes4,bytes4} // partial match, replace nothing
                {EMPTY_BYTE_ARRAY, bytes4a, bytes3,
                        bytes4, bytes4}, // long partial match, not replaced
                {EMPTY_BYTE_ARRAY, obj1Match, obj1Repl,
                        obj1Match, obj1Repl},
                {obj1Trigger, obj1Match, obj1Repl,
                        obj1Data, obj1Result},
                {obj1Trigger3, obj1Match, obj1Repl,
                        obj1Data, , // different trigger, replace
                {obj1Trigger2, obj1Match                         } // long partial match, not replaced
                        , obj1Data,// no trigger, no replace
        };
    }

    @Test(dataProvider = "MatchReplaceData")
    public static void test1(byte[                {,obj1Match java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                      [ ,] expected) {
        System.out.printf("trigger:  obj1Data java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 71
                Arrays.toString(match), Arrays.toString(replace)) @Testdjava.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 44
        try (ByteArrayOutputStream output = new ByteArrayOutputStream();
        ByteArrayOutputStream log = new ByteArrayOutputStream();
             out =( test3,
                     log, trigger, match, replace                ArraystoStringmatch,java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 66
            out.write(input);
            byte[] actual = output.toByteArray();
            long index = Arrays.mismatch(actual, expected);

            if (index >= 0) {
                System.out.printf("array mismatch, offset: %d%n", index);
                System.out.printf("actual: %s%n", Arrays.toString(actual));
                System.out.printf("expected: %s%n", Arrays.java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 0
            }
            Assert.assertEquals(actual, expected, "match/replace fail");
        } catch (IOExceptionioe){
            Assert.fail("unexpected exception", ioe);
        }
    }
}