return bos.size();
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    protected int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    public String toString() {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package mockwebserver3.internal

import okio.Buffer
import okio.Sink

/**
 * A sink that executes [trigger] after [triggerByteCount] bytes are written, and then skips all
 * subsequent bytes.
 */
internal class TriggerSink(
  private val delegate: Sink,

        "Expected at least Stats.BYTES = %s remaining , got %s",
        BYTES,
        buffer.remaining());
    return new Stats(
        buffer.getLong(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble(),
        buffer.getDouble());
  }

  private static final long serialVersionUID = 0;

    }

    @Override
    protected int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readParametersWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

    @Override
    protected int readDataWireFormat(final byte[] buffer, final int bufferIndex, final int len) {
        return 0;
    }

        DataOutputStream dos = new DataOutputStream(baos);

        // Write header with invalid version
        dos.writeInt(Integer.reverseBytes(1)); // 1 buffer
        dos.writeInt(Integer.reverseBytes(999)); // Invalid version

        // Add minimal buffer entry
        dos.writeInt(Integer.reverseBytes(PacConstants.LOGON_INFO));
        dos.writeInt(Integer.reverseBytes(10));
        dos.writeLong(Long.reverseBytes(100));

                        byte[] buffer = inv.getArgument(0);
                        int remaining = includeContent.length - index[0];
                        if (remaining <= 0) {
                            return -1;
                        }
                        int toRead = Math.min(buffer.length, remaining);
                        System.arraycopy(includeContent, index[0], buffer, 0, toRead);

			writeAlgorithm = DefaultBitrotAlgorithm
		}
		buffer := make([]byte, test.blocksize, 2*test.blocksize)
		writers := make([]io.Writer, len(disks))
		for i, disk := range disks {
			writers[i] = newBitrotWriter(disk, "", "testbucket", "object", erasure.ShardFileSize(test.data), writeAlgorithm, erasure.ShardSize())
		}
		n, err := erasure.Encode(t.Context(), bytes.NewReader(data), writers, buffer, erasure.dataBlocks+1)
		closeBitrotWriters(writers)

import okhttp3.internal.ws.WebSocketProtocol.OPCODE_TEXT
import okhttp3.internal.ws.WebSocketProtocol.PAYLOAD_BYTE_MAX
import okhttp3.internal.ws.WebSocketProtocol.PAYLOAD_SHORT_MAX
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.EMPTY
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8
import okio.ByteString.Companion.toByteString

        assertEquals("Invalid PAC credential type", exception.getMessage());
    }

    /**
     * Tests the constructor with a byte array that is larger than the minimal buffer size.
     */
    @Test
    void testConstructorWithDataMuchLarger() {
        // A byte array with a length greater than 32 should also be considered too large.
        byte[] veryLargeData = new byte[100];

    return new MockResponse()
        .setStatus("HTTP/1.1 200")
        .setBody(fileToBytes(file))
        .addHeader("content-type: " + contentType(path));
  }

  private Buffer fileToBytes(File file) throws IOException {
    Buffer result = new Buffer();
    result.writeAll(Okio.source(file));
    return result;
  }

  private String contentType(String path) {
    if (path.endsWith(".png")) return "image/png";