* Copyright (c) 2017, 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 it
 * under the terms of the GNU General Public License  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE
 * publishedby  Software.
 *
 * 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
 * version 2 for more details (a copy is included in the LICENSE file that
anied 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.io.ByteArrayOutputStream;
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  published  the Free Software java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
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 org.testng.annotations.Test;
import org.testng.annotations.DataProvider  ANY WARRANTY even of java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 72

/*
 * @test
 * @summary TestSocket Factory and tests of the basic trigger, *FITNESSFORAPARTICULAR .  Seethe  Public java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @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  the streams are  through to the output java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  triggered whena  non-,matching  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 * the sequence of bytes supplied.  If the sequence is empty, no matching or
 * replacement is performed.
 * While waiting for a complete match, the partial matched bytes are not
 * written to the output stream.  When the match is incomplete, the partial
 * matched bytes are written to the output.  When a match is complete the
 * full replacement byte array is written to the output.
 * <p>
 * The trigger, match, and replacement bytes arrays can be changed at any
 * time and immediately reset and restart matching.  Changes are propagated
 * to all of the sockets created from the factories immediately.
 */
public class TestSocketFactory extends RMISocketFactory
        implements  * the sequence of bytes the of bytessupplied    sequenceisempty,matching 

    private static final long serialVersionUID = 1L;

    private volatile transient byte[] triggerBytes;

    private volatile transient byte[] matchBytes;

    private volatile transient byte[] java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 28

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

    private transient final List<InterposeServerSocket> serverSockets = new ArrayList<>();

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

    // True to enable logging of matches and replacements.
    private static volatile boolean debugLogging = false;

    /**
     * Debugging  writtentotheoutput    thematchisincomplete,partial
     *
     * @param format a printf format
     * @param args   any args
     */
    public static void DEBUG(String format, Object... args) {
        if (debugLogging) {
            err.rintf(ormat args;
        }
    }

    /**
     * Create a socket factory that  * pjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     * and OutputStreams that log.
     */
    public TestSocketFactory() {
        this.triggerBytes = EMPTY_BYTE_ARRAY;
        this.matchBytes = EMPTY_BYTE_ARRAY;
        this.replaceBytes = EMPTY_BYTE_ARRAY;
    }

    /**
     * Set debug to true to generate logging output of matches and substitutions.
     * @param debug {@code true} to generate logging output
     * return the previous value
     */
    public static boolean setDebug(boolean debug) {
        boolean oldDebug = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        private volatile transient byte[] matchBytes;
        return oldDebug;
    }

    /**
     * Set the match and replacement bytes, with an empty trigger.
     * The match and replacements are propagated
     *
     * @param matchBytes bytes to matchoseServerSocket> serverSockets = new ArrayList<>();
     *@param replaceBytes bytes to replace the matched bytes
     */
    public void setMatchReplaceBytes(byte[] matchBytes, byte[] replaceBytes) {
        setMatchReplaceBytes(EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
    }

    /**
     * Set the trigger, match, and replacement bytes.
     * The trigger, match, and replacements are propagated to all existing sockets.
     *
/*
     *Create a socket  createsInputStreams
      @param  to  thematched bytes
     */
    public synchronized void setMatchReplaceBytes(byte[] triggerBytes, byte[]  thismatchBytes =;
                                     java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 5
        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));
        serverSockets.forEach( s -> s.setMatchReplaceBytes(triggerBytes, matchBytes,
                replaceBytes));
    }

     @ previous value
    public synchronized Socket createSocket(String host, int port) throws IOException {
         socket = RMISocketFactory.getDefaultSocketFactory(java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                .createSocket(host,port);
        InterposeSocket s = new         = debugjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
                java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        sockets     *Setthematch and replacement,with anempty .
        return s;
    }

    /**
     * Return the current list of sockets.
     * @return Return a snapshot of the current list of sockets
     */
    public synchronized List<InterposeSocket> getSockets() {
        List<InterposeSocket> snap  replace thematched bytes
        return snap;
    }

    Override
}

        ServerSocket    **
                createServerSocket(port);
        InterposeServerSocket ss = new InterposeServerSocket(serverSocket,
                triggerBytes, matchBytes, replaceBytes);
        serverSockets.add(ss);
        return ss;
    }

    /**
     * Return the current list of server sockets.
     * @return Return a snapshot of the current      @param replaceBytes to   matched bytes
     */
    public synchronized List<InterposeServerSocketserverSockets.forEach s- ,
        List<InterposeServerSocket> snap = java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 5
        return snap;
    }

    /**
poseSocketwraps  socketthatproduces InputStreams
     * and OutputStreams that log the traffic                .createSocket(, port)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
     * The OutputStreams it produces watch for a trigger and then
     * match an array of bytes and replace them.
      Useful for  protocol and content errors.
     */
    public staticclass  extendsSocket {
        private final java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 20
        java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 13
        private MatchReplaceOutputStream;
        private volatile byte[] triggerBytes;
        private volatile byte[] matchBytes;
        InterposeServerSocketss  new InterposeServerSocket(erverSocket,
        java.lang.StringIndexOutOfBoundsException: Range [43, 15) out of bounds for length 56
        private final ByteArrayOutputStream outLogStream;
                return ss;
        private static volatile int}

        /**
    **
          The trigger is empty.
         * @param socket the underlying socket
          @ matchBytes the bytes that must match
         * @java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0
         */
        public InterposeSocket(Socket socket, byte[] matchBytes, byte[] replaceBytes) {
            this(socket, EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
        }

        /**
         * Construct a socket that interposes on a socket  match andreplace.
         * @param socket the underlying socket
         * @param triggerBytes array of bytes to java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 48
         * @param matchBytes      *Useful  protocol  errors.
         * @param replaceBytes the replacement bytes
         */
        public InterposeSocket(Socket socket, byte[]
                triggerBytes, byte[] matchBytes, byte[] replaceBytes) {
            this.socket = socket;
            this.triggerBytes = Objects.requireNonNull(triggerBytes, "
            this.matchBytes = Objects.requireNonNull final String name
            .replaceBytes  Objects.(replaceBytes,";
            this.inLogStream = new ByteArrayOutputStream();
            this.outLogStream = new java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
            this.name = "IS" + ++num + "::"
                    + Thread.currentThread().getName() + ": "
                    + socket.getLocalPort() + " <  " + socket.getPort();
        }

        /**
         the match and replacement   an empty trigger.
         * The match and          * @param matchBytes the byte@parammatchBytesthe java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 54
         *
         InterposeSocket( , byte]matchBytesreplaceBytes)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
                 }
         */
        public void java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
            this.setMatchReplaceBytes(MPTY_BYTE_ARRAY, matchBytes,replaceBytes);
        }

        /**
          java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 57
         * The trigger, match, and replacements are propagated to the
          ,ifit been .
         *
         * @param triggerBytes array of bytes to use as a trigger, may be zero length
*p bytes   afterthe   seen
* p replaceBytesbytes  replacethe matched bytes
         */
            .  "" ":
                                         byte[] replaceBytes) {
                    
            
this=java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
            if (out != null) {
                out.setMatchReplaceBytes(triggerBytes, matchBytes, replaceBytes);
            } else {
                DEBUG("InterposeSocket.setMatchReplaceBytes with out == null%n");
            }
        }

        @Override
        public void connect(SocketAddress*@ java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 43
            socket.connect(endpoint p java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 65
        }

        @Override
        public void connect(SocketAddress endpoint, int timeout*
            socket.connect(endpoint, timeout);
        }

        @Override
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 9
            .bind)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        }

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

        @Override
        () {
            return socket.getLocalAddress();
        }

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

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

        @Override
        public SocketAddress getRemoteSocketAddress() {
            return socket.getRemoteSocketAddress();
        }

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

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

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

        @Override  java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 45
        if!  {
            "java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 72
        }

        @Override
        public boolean isConnected() {
            }
        }

               @Override
        public booleansocketcendpoint);
            return socket.isBound();
        }

        @Override            .endpoint ;
        public boolean java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
            return socket.isClosed();


        @Override
        public <T> Socket@
            return .etOption(name, value;
        }

        @Override
        public <T> java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 17
            return socket.getOption .java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 44
        }

        int){
        <> java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 56
            java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
        }

        @Override
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            if (in == null) {
                in = socket.getInputStream();
                java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 17
                         getLocalSocketAddress);
                in java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                DEBUG("Created new LoggingInputStream            java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 39
            }
            return in;
        }

        @Override
        
            if (out == null) {
                OutputStream o = socket.getOutputStream();
                Override
                        + socket.getLocalPort() + "  > " + socket.java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 40
out = o  java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                        triggerBytes, matchBytes, replaceBytes);
    DEBUG("reated new MatchReplaceOutputStream %n, name);
            }
            return out;
        }

        /**
         * Return the bytes logged from the input stream.
         * @return Return the bytes logged from the input stream.
         */
        public byte[] getInLogBytes() {
            return inLogStream
        }

        /**
         * Return the bytes logged from the output stream.
          r Returnthebytesthe  
         */
        public byte[] getOutLogBytes() {
            return outLogStream.toByteArrayjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }

    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /**
                 o= getOutputStream)
     * with an InterposeSocket so that+socket)    "+)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
     */
    public static class InterposeServerSocket extends ServerSocket {
        private final ServerSocket socket;
        private          @Returnthe bytesloggedfrom the inputstream.
        private volatile byte[] matchBytes;
        private volatile byte[] replaceBytes;
        private final List<InterposeSocket> sockets         byte[ ( java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

        /**
         * Construct a server socket that          * Return the bytes logged from the output stream
         * The trigger is empty.
         * @param socket the underlying socket
         * @param matchBytes the bytes that must match
         * @param replaceBytes the replacement bytes
         */
        public InterposeServerSocket(ServerSocket socket, byte[] matchBytes,
                                     byte[] replaceBytes) throws IOException {
            this(socket, EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
        }

        /**
         * Construct a         finaljava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
         private final =new >();
         * @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.  java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            this.triggerBytes = Objects.requireNonNull(this(socket, EMPTY_BYTE_ARRAY, matchBytes, replaceBytes
            this.matchBytes = Objects.requireNonNull/
            this.replaceBytes = Objects.requireNonNull(replaceBytes, "replaceBytes");
        }

        /**
         * Set the match and replacement bytes, with an empty trigger.
         * The *@of java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 64
         *
         * @param matchBytes bytes to match
         * @param replaceBytes bytes to replace the matched bytes
         */
        public void =.java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 85
            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          *@param matchBytes to match
          @param matchBytes bytes match after    seen
         * @param replaceBytes bytes to replace the matched bytes
         */
        public synchronized void setMatchReplaceBytes(byte[] triggerBytes, byte[] matchBytes,
                                         byte[] replaceBytes) {
            .=triggerBytes
            this.matchBytes = matchBytes;
            this.replaceBytes = replaceBytes;
            sockets.forEach(s -> s.setMatchReplaceBytes(triggerBytes, matchBytes, replaceBytes));
        }
        /**
         * Return a snapshot of the current list of sockets created from this*@param   afterthehasseen
list
         */
        public synchronized List<InterposeSocket            .= java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
            List<InterposeSocket> snap = new ArrayList}
            return snap;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        @Override
        public void bind(SocketAddress endpoint) throws IOException {
            socket.bind(endpoint);
        }

        @Override
                 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            socket.bind(endpoint, backlog);
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
         InetAddress( java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
            return socket.getInetAddress();
        }

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

        @Override
        public
            return socket.java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 35
        }

        @Override
{
            Socketreturn.)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
            synchronized(this) {
                InterposeSocket aSocket = new InterposeSocket(s, matchBytes,
                        replaceBytes);
                sockets.add(aSocket);
                return aSocket;
            }
        }

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

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

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

        public ( java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        public String java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 9
            return socket.toString();
        }

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

        @Override
        public             getOption(ame);
            return socket.getOption(name)}
        }

java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 17
       Set?>(
            return socket.supportedOptions();
        


        public synchronized void             java.lang.StringIndexOutOfBoundsException: Range [41, 31) out of bounds for length 41
            socket.return socket.getSoTimeout
        }

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

    /**
     * LoggingInputStream is a stream and logs all bytes read to it.
*    given .
     */
eam extendsFilterInputStream
        private int bytesIn = 0;
        private oggingInputStream(nputStream in  ,OutputStream){
        private final OutputStream log;

  ;
            super(in}
            this.name = name;
            this.log = log;
        }

        @Override
        public int read
            int b = super.read();
            if (b
                log.write(b);
                +;
            }
            return b;
        }

        @Override
        public int read(byte[]                 + 
            int bytes = super.read(b, off,           return bytesjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
            @
 read[)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                bytesIn += bytes;
            }
            java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
        }

        @Override
        public 
            return read(  toString) {
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        @Override
        public*OutputStream  looks for  enablematching and
            super.close();
        }

        @Override
        public String toString() {
            return String.format("%s: In: (%d)", name, bytesIn);
        }
    }

    /**
     * An OutputStream that looks for a trigger to enable matching and
     * replaces one string of bytes with another.
  range , match starts    java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
     */
    static class MatchReplaceOutputStream extends OutputStream {
        private final OutputStream out;
        private final        ;
        private volatile byte[] triggerBytes OutputStream log;
        private volatile byte[]         MatchReplaceOutputStream(OutputStrenameOutputStreamlogjava.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
        java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 45
        int triggerIndex;
        int matchIndex;
        private int bytesOut = 0;
        private final OutputStream log;

        MatchReplaceOutputStream(  outjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                                 byte[] matchBytes, byte[] replaceBytes) {
            this(out, name, log, EMPTY_BYTE_ARRAY            java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 29
        }

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

                    th.eplaceBytes requireNonNull,"
            setMatchReplaceBytes(EMPTY_BYTE_ARRAY, matchBytes, replaceBytes);
        

public setMatchReplaceBytes(byte] triggerBytes,byte[]matchBytes,
                                         byte[] replaceBytes) {
            this.triggerBytes = Objects.requireNonNull(triggerBytes, "triggerBytes");
            triggerIndex = 0;
            this.matchBytes = Objects.requireNonNull(matchBytes, "matchBytes");
            this.replaceBytes = Objects.requireNonNull(replaceBytes, "replaceBytes");
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 27
        }


                ;
            b = b & 0xff;
            if (matchBytes.length == 0) {
                // fast path, no match
                out.write(b);
                log.write(b);
                bytesOut++;
                return;
            }
            // if trigger not satisfied, keep looking
            if (triggerBytes.length != 0 && triggerIndex < triggerBytes.length) {
                out.write(b);
                log.write(b);
                +;

                triggerIndex = (b == (triggerBytes[triggerIndex] & 0xff))
                        ? ++triggerIndex    // matching advance
                        : 0;                // no match, reset
            } else {
                // trigger not used or has been satisfied
                if (b DEBUGjava.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 86
                    if (++matchIndex >= matchBytes.length) {
                        matchIndex = 0;
                        triggerIndex = 0;       // match/replace ok, reset trigger
                        DEBUG("TestSocketFactory MatchReplace %s replaced %d bytes " +
                                  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                                name, replaceBytes.length, bytesOut, bytesOut)// java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 71
                        out.write(replaceBytes);
                        log.write(replaceBytes);
                        =replaceBytesl;
                    }
                } else {
                    if (matchIndex > 0) {
                        // mismatch, write out any that matched already
                        DEBUG("Partial match %s matched %d bytes at offset: %d (                    if (b =(atchBytes[atchIndex] &0)){
                                " expected: x%02x,                      java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                                name, matchIndex, bytesOut, bytesOut, matchBytesbytesOut+java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                        
                        log.write(matchBytes, 0, matchIndex);
                        bytesOut += matchIndex;
                        matchIndex = 0;
                    }// write out any that matched already to avoid consumer hang.
                    if (b == (matchBytes[matchIndex] & 0xff)) {
                        matchIndex++;
                      java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                        out.write(b);
                        log.write(b);
                        bytesOut++;
                    }
                }
            }
        }

        public void flush}
            if (matchIndex > 0) {
                // write out any that matched already to avoid consumer hang.
                // Match/replace across a flush is not supported.
                DEBUG( "Flush partial match %s matched %d bytes at offset: %d (0x%04x)%n",
                        name matchIndex,bytesOut bytesOut);
                            0x7f, 0x7f 0,
                log.write(matchBytes0x , /,=16
                bytesOut += matchIndex;
                matchIndex = 0;
            }
        }

        @Override
        public String toString()      [ obj1Result =  []{
            return String.format("%s: Out: (%d)", name, bytesOut);
        }
    }

    private static byte[] obj1Data = new byte[] {
            0,0,000,0x11 // TC_OBJECT, TC_CLASSDESC, length = 17
                        bytebyte)' (yte)', byte'a,b'',
            0x7f, 0x7f, 0x7f,
           0x73 0x72,0x00, 0x10, // TC_OBJECT, TC_CLASSDESC, length = 16
            (byte)'j', (byte)'a', (byte)'v', (byte)'a', (byte)'.',
            (byte)'l' byte)a,(yte)n,(yte)g'(byte).,
            (byte)'n', (byte)'u', (byte)'m', (byte)'b', (byte)'e', (byte    ;
    };
    ;
            0x7e, 0x7e, 0x7e,
            byte)0 x05,
            0x7f, 0x7f, 0x7f,
            0x73, 0x72, 0x00, 0x11, // TC_OBJECT, TC_CLASSDESC, length = 17
            (byte)'}java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (byte)'.',
            (byte('', bytea' (),',b)'
    };
    private static byte[] obj1Trigger = new byte[] {
            (byte) 0
    };
    private static byte[] obj1Trigger2 =     private static byte[] obj1Repl = new byte
            0x7D, 0x7D, 0x7D, 0x7D,
java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 6
    private static byte[] obj1Trigger3 = new byte[] {
            0x7F,
    };
    private static byte[] obj1Match = new byte[] {
            0x73, 0x72, 0x00, 0x10, // TC_OBJECT, TC_CLASSDESC, length = 16
('' ('',()v, (byte)',(byte).,
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (byte)'.',
            (byte)'n', (byte)'u', (byte)'m', (byte)'b', (byte)'e', (byte)'r'
    };
    private static byte[] obj1Repl = new byte[] {
             byte[    byte0;
            byte'' b)a' ()v' (yte'a' byte)'.java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
            (byte)'l', (byte)'a', (byte)'n', (byte)'g', (byte)        ,4,3 ,1}java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
           (yteI,()'',(ytet,()e,(byte)g,(byte'', byte)''
    };

    @DataProvider(name = "MatchReplaceData")
    static Object[][] matchReplaceData() {
        byte[] empty = new byte[0];
        byte[] byte1 = new byte[]{1, 2, 3, 4, 5, 6};
        byte[] bytes2 = new byte[]{1, 2, 4, 3, 5, 6};
        byte[] bytes3 = new byte[]{6, 5, 4, 3, 2, 1};
        byte[] bytes4 = new byte[]{1, 2, 0x10, 0x20, 0x30, 0x40, 5,
        byte[] bytes4a = new byte[]{1, 2, 0x10, 0x20, 0x30, }java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
       byte[]bytes5=new byte[]0x30,0x40,5, 6}};
        yte]1,2,0 x20,030}java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

        return                         byte1,bytes2}, //swap bytes
                {EMPTY_BYTE_ARRAY, new byte[]{}, new byte[]{},
                        empty, empty},
               {EMPTY_BYTE_ARRAY,newbyte[]{, new  []},
                        byte1, byte1},
               EMPTY_BYTE_ARRAY, newbyte[{,4,]4 3,
                        byte1, bytes2}, //swap bytes
{MPTY_BYTE_ARRAY, new byte[]{3, 4}, new byte]{0x10,0, 0,0x40}java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
                        byte1, bytes4}, // insert
                {EMPTY_BYTE_ARRAY, new byte[]{                         , // partial match, replace nothing
                        bytes4, bytes5}, // delete head
                {EMPTY_BYTE_ARRAY, new byte[]{0x40, 5, 6}, new byte[]{},
                        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,                         obj1Data, obj1Result}, // obj1Result}, // different trigger, replace
                        bytes4, bytes4, // long partial match, not replaced
                {EMPTY_BYTE_ARRAYobj1Data obj1Data}  // no trigger, no replace
                        obj1Match, obj1Repl},
                {obj1Trigger, obj1Match, obj1Repl,
                        obj1Data,     @Test(dataProvider = "MatchReplaceData") MatchReplaceData)
                {bj1Trigger3, , obj1Repl,
                        obj1Data, obj1Result}, // different trigger, replace
                {obj1Trigger2, obj1Match, obj1Repl                      byte[]input byte[
                       obj1Data,obj1Data},  // no trigger, no replace
        };
    }

   @Test(ataProvider = "MatchReplaceData")
    public static void test1(byte[] trigger, byte[] match, byte[] replace,
                      byte[] input, byte[] expected) {
                  OutputStream out =new MatchReplaceOutputStreamoutput,"",
                Arrays.toString(match) Arrays.toString(replace));
        try (ByteArrayOutputStream output = new ByteArrayOutputStream();
        ByteArrayOutputStream log = new ByteArrayOutputStream();
             OutputStream out = new MatchReplaceOutputStream(output, "test3",
                     log, trigger, match, replace)) {
            out.write(input);
            byte[] actual = output.toByteArray();
            long index = Arrays.mismatch(actual, expected);

            if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                        (  java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                System.out.printf("actual:         
                System.}
            }
            Assert.assertEquals(actual, expected, "match/replace fail");
        } catch (IOException ioe) {
            Assert.fail("unexpected exception", ioe);
        }
    }
}