}

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    // Override slow FilterOutputStream impl
    out.write(b, off, len);
  }

  @Override
  public void writeBoolean(boolean v) throws IOException {
    ((DataOutputStream) out).writeBoolean(v);
  }

  @Override
  public void writeByte(int v) throws IOException {
    ((DataOutputStream) out).writeByte(v);
  }

func getListQuorum(quorum string, driveCount int) int {
	switch quorum {
	case "disk":
		return 1
	case "reduced":
		return 2
	case "optimal":
		return (driveCount + 1) / 2
	case "auto":
		return -1
	}
	// defaults to 'strict'
	return driveCount
}

func calcCommonWritesDeletes(infos []DiskInfo, readQuorum int) (commonWrite, commonDelete uint64) {

## How are drives used for Erasure Code?

MinIO divides the drives you provide into erasure-coding sets of *2 to 16* drives.  Therefore, the number of drives you present must be a multiple of one of these numbers.  Each object is written to a single erasure-coding set.

    }

    /**
     * Returns a new array with the specified int value appended to the end of the int array.
     *
     * @param array
     *            the array. Must not be {@literal null}
     * @param value
     *            the value to add
     * @return a new array with the value appended
     */
    public static int[] add(final int[] array, final int value) {
        assertArgumentNotNull("array", array);

    public static final int SEQUENCE_CHECKING = 0x10;
    /**
     * Context flag for anonymity capability
     */
    public static final int ANONYMITY = 0x08;
    /**
     * Context flag for confidentiality (encryption) capability
     */
    public static final int CONFIDENTIALITY = 0x04;
    /**
     * Context flag for integrity (signing) capability
     */
    public static final int INTEGRITY = 0x02;

        // When - Multiple threads accessing trees concurrently
        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await(); // Wait for all threads to be ready

                    for (int i = 0; i < opsPerThread; i++) {

     */
    private static class TestBufferCacheImpl implements BufferCache {
        private final List<byte[]> cache;
        private final int bufferSize;
        private final int maxBuffers;

        public TestBufferCacheImpl(int maxBuffers, int bufferSize) {
            this.maxBuffers = maxBuffers;
            this.bufferSize = bufferSize;
            this.cache = new ArrayList<>(maxBuffers);
        }

    }

    @Override
    int writeBodyWireFormat(final byte[] dst, final int dstIndex) {
        return writeQuestionSectionWireFormat(dst, dstIndex);
    }

    @Override
    int readBodyWireFormat(final byte[] src, final int srcIndex) {
        return readQuestionSectionWireFormat(src, srcIndex);
    }

    @Override
    int writeRDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    SmbComWriteAndXResponse() {
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        count = readInt2(buffer, bufferIndex) & 0xFFFFL;

    }

    /**
     * Constant-time array copy to prevent timing attacks
     */
    private void constantTimeCopy(byte[] src, int srcPos, byte[] dest, int destPos, int length) {
        // Simple constant-time copy - always process all bytes
        for (int i = 0; i < length; i++) {
            dest[destPos + i] = src[srcPos + i];
        }
    }

    /**
     * Decrypt an SMB2 message
     *