derWriter.writeUtf8("a".repeat(201))
    }

    assertThat(buffer.readByteString(3)).isEqualTo("1e81c9".decodeHex())
    assertThat(buffer.readUtf8()).isEqualTo("a".repeat(201))
  }

  @Test fun `decode primitive bit string`() {
    val buffer =
      Buffer()
        .write("0307040A3B5F291CD0".decodeHex())

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

    }

    /**
     * Decode a transform header from byte array
     *
     * @param buffer
     *            buffer to decode from
     * @param bufferIndex
     *            offset in buffer
     * @return new transform header instance
     */
    public static Smb2TransformHeader decode(final byte[] buffer, int bufferIndex) {
        final Smb2TransformHeader header = new Smb2TransformHeader();

    mockResponse.headers = headersOf()
    mockResponse.trailers = headersOf()
    mockResponse = mockResponse.removeHeader("")
    var body: Buffer? = mockResponse.getBody()
    mockResponse = mockResponse.setBody(Buffer())
    mockResponse = mockResponse.setChunkedBody(Buffer(), 0)
    mockResponse = mockResponse.setChunkedBody("", 0)
    var socketPolicy: SocketPolicy = mockResponse.socketPolicy

        final int zt = zterm ? 1 : 0;

        length = maximum_length = (short) ((len + zt) * 2);
        buffer = new short[len + zt];

        int i;
        for (i = 0; i < len; i++) {
            buffer[i] = (short) str.charAt(i);
        }
        if (zterm) {
            buffer[i] = (short) 0;
        }
    }

    @Override
    public String toString() {

expanded_policy_count=$(./mc admin policy list myminio/ | wc -l)

if [ $user_count -ne $expanded_user_count ]; then
	echo "BUG: original user count differs from expanded setup"
	exit 1
fi

if [ $policy_count -ne $expanded_policy_count ]; then
	echo "BUG: original policy count  differs from expanded setup"
	exit 1
fi

./mc version info myminio/versioned | grep -q "versioning is enabled"
ret=$?
if [ $ret -ne 0 ]; then

            assertEquals(0, smbComTreeDisconnect.readBytesWireFormat(buffer, i));
        }
    }

    /**
     * Test boundary conditions for buffer indices
     */
    @Test
    @DisplayName("Test boundary conditions for buffer indices")
    public void testBoundaryConditions() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[100];

        // Encode first
        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        // Create new context for decoding
        CompressionNegotiateContext decodedContext = new CompressionNegotiateContext();
        int decodedSize = decodedContext.decode(buffer, 0, encodedSize);

        assertEquals(encodedSize, decodedSize);

        this.leaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.leaseFlags = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // LeaseDuration (8 bytes) - reserved, skip
        bufferIndex += 8;

        byte[] parentKeyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, parentKeyBytes, 0, 16);

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.numberOfLinks = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 9) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

        final int bufferOffset = SMBUtil.readInt2(buffer, bufferIndex + 2) + getHeaderStart();