for (int i = 0; i < key.length; i++) {
            if (i > 0) {
                sb.append(' ');
            }
            sb.append(String.format("%02X", key[i] & 0xFF));
        }
        sb.append(']');
        return sb.toString();
    }

        bufferIndex += 8;
        fileType = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        deviceState = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        directory = (buffer[bufferIndex++] & 0xFF) > 0;

        return bufferIndex - start;
    }

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

    @Override

        // Write test data at the specified offset
        byte[] testData = new byte[dataLength];
        for (int i = 0; i < dataLength; i++) {
            testData[i] = (byte) (i & 0xFF);
        }
        System.arraycopy(testData, 0, buffer, dataOffsetFromHeader, dataLength);

        // Use reflection to set headerStart

        tmp = new byte[TMP_BUFFER_SIZE];
    }

    @Override
    public synchronized int read() throws IOException {
        if (read(tmp, 0, 1) < 0) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    @Override
    public synchronized int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /* This method will not return until len bytes have been read

    require(streamId and 0x80000000.toInt() == 0) { "reserved bit set: $streamId" }
    sink.writeMedium(length)
    sink.writeByte(type and 0xff)
    sink.writeByte(flags and 0xff)
    sink.writeInt(streamId and 0x7fffffff)
  }

  @Throws(IOException::class)
  override fun close() {
    withLock {
      closed = true
      sink.close()
    }
  }

        assertEquals("Pattern_V1", CompressionNegotiateContext.getAlgorithmName(CompressionNegotiateContext.COMPRESSION_PATTERN_V1));
        assertTrue(CompressionNegotiateContext.getAlgorithmName(0xFF).startsWith("Unknown"));
    }

    @Test
    @DisplayName("Test empty algorithms context")
    public void testEmptyAlgorithms() {

    void testLeaseKeyAccessors() {
        byte[] newKeyBytes = new byte[] { (byte) 0xFF, (byte) 0xFE, (byte) 0xFD, (byte) 0xFC, (byte) 0xFB, (byte) 0xFA, (byte) 0xF9,
                (byte) 0xF8, (byte) 0xF7, (byte) 0xF6, (byte) 0xF5, (byte) 0xF4, (byte) 0xF3, (byte) 0xF2, (byte) 0xF1, (byte) 0xF0 };
        Smb2LeaseKey newKey = new Smb2LeaseKey(newKeyBytes);

        leaseContext.setLeaseKey(newKey);

     * @throws SmbException if an I/O error occurs
     */
    public int read() throws SmbException {
        if (read(tmp, 0, 1) == -1) {
            return -1;
        }
        return tmp[0] & 0xFF;
    }

    /**
     * Reads bytes from the file into the specified byte array.
     *
     * @param b the byte array to read data into
     * @return the number of bytes read, or -1 if end of file is reached

        try {
            descr = DESCR[which].getBytes("ASCII");
        } catch (final UnsupportedEncodingException uee) {
            return 0;
        }

        writeInt2(subCommand & 0xFF, dst, dstIndex);
        dstIndex += 2;
        System.arraycopy(descr, 0, dst, dstIndex, descr.length);
        dstIndex += descr.length;
        writeInt2(0x0001, dst, dstIndex);
        dstIndex += 2;

     */
    public void enc_ndr_small(final int s) {
        buf[index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */
    public int dec_ndr_small() {
        final int val = buf[index] & 0xFF;
        advance(1);
        return val;
    }

    /**