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

        Object obj;
    }

    /**
     * The underlying byte buffer containing the NDR data.
     */
    public byte[] buf;

    /**
     * The starting position in the buffer.
     */
    public int start;

    /**
     * The current position in the buffer.
     */
    public int index;

    /**
     * The length of data in the buffer.
     */
    public int length;

    /**

        bufferIndex += 2;
        this.size = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.serverType = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        this.rflags = SMBUtil.readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        if (this.version == 3) {
            this.proximity = SMBUtil.readInt2(buffer, bufferIndex);
            bufferIndex += 2;

    @DisplayName("Test decode method with valid buffer")
    void testDecodeWithValidBuffer() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[256];
        int bufferIndex = 0;
        int expectedLength = 100;

        when(messageBlock.decode(buffer, bufferIndex)).thenReturn(expectedLength);

        // When
        int actualLength = messageBlock.decode(buffer, bufferIndex);

        // Then

        info.allocationSize = readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        info.endOfFile = readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        info.numberOfLinks = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        info.deletePending = (buffer[bufferIndex] & 0xFF) > 0;
        bufferIndex++;
        info.directory = (buffer[bufferIndex++] & 0xFF) > 0;
        this.info = info;

  private fun String.map(): String {
    val buffer = Buffer()
    for (codePoint in codePoints()) {
      require(table.map(codePoint, buffer))
    }
    return buffer.readUtf8()
  }

  private fun String.mapExpectingErrors(): String {
    val buffer = Buffer()
    var errorCount = 0
    for (codePoint in codePoints()) {
      if (!table.map(codePoint, buffer)) errorCount++
    }

        byte[] buffer = new byte[100];

        // Define behavior
        when(mockFileInfo.decode(buffer, 0, 100)).thenReturn(8);

        // Test decode
        int decoded = mockFileInfo.decode(buffer, 0, 100);
        assertEquals(8, decoded);

        // Verify interaction
        verify(mockFileInfo).decode(buffer, 0, 100);
    }

    /**

            // Encode
            byte[] buffer = new byte[1024];
            int encodedSize = original.encode(buffer, 0);

            // Decode
            PreauthIntegrityNegotiateContext decoded = new PreauthIntegrityNegotiateContext();
            int decodedSize = decoded.decode(buffer, 0, encodedSize);

            // Verify
            assertEquals(encodedSize, decodedSize);

        val read = delegate.read(buffer, byteCount)
        if (read != -1L) {
          sink.write(buffer.readByteString().toAsciiUppercase())
        }
        return read
      }
    }
  }

    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        buffer[bufferIndex] = (byte) 0x00; // Reserved
        bufferIndex++;
        buffer[bufferIndex++] = (byte) 0x00; // Reserved
        buffer[bufferIndex++] = (byte) 0x00; // Reserved

        this.totalParameterCount = SMBUtil.readInt4(buffer, bufferIndex);
        if (this.bufDataStart == 0) {