assertEquals("\\", trans2FindFirst2.getPath());
    }

    @ParameterizedTest
    @DisplayName("Test search attributes masking")
    @ValueSource(ints = { 0x00, 0x16, 0x37, 0xFF })
    void testSearchAttributesMasking(int searchAttributes) {
        trans2FindFirst2 = new Trans2FindFirst2(mockConfig, "\\test", "*.*", searchAttributes, 10, 1024);

        // Verify attributes are masked with 0x37

        bufferIndex += 2;
        if (this.dialectIndex > 10) {
            return bufferIndex - start;
        }
        this.server.securityMode = buffer[bufferIndex] & 0xFF;
        bufferIndex++;
        this.server.security = this.server.securityMode & 0x01;
        this.server.encryptedPasswords = (this.server.securityMode & 0x02) == 0x02;

    // Disable the timeout to read the first byte of a new frame.
    val b0: Int
    val timeoutBefore = source.timeout().timeoutNanos()
    source.timeout().clearTimeout()
    try {
      b0 = source.readByte() and 0xff
    } finally {
      source.timeout().timeout(timeoutBefore, TimeUnit.NANOSECONDS)
    }

    opcode = b0 and B0_MASK_OPCODE
    isFinalFrame = b0 and B0_FLAG_FIN != 0

        }
        if (length < 0) {
            throw new EOFException("EOF found when length expected");
        }
        if (0xFF == length) {
            throw new IOException("invalid long form definite-length 0xFF");
        }

        final int octetsCount = length & 0x7F;
        int octetsPos = 0;

        length = 0;
        do {
            final int octet = s.read();
            if (octet < 0) {

        assertArrayEquals(zeroGuid, extractedGuid);
    }

    @Test
    @DisplayName("Test encode with all 0xFF GUID")
    void testEncodeWithMaxGuid() {
        byte[] maxGuid = new byte[16];
        Arrays.fill(maxGuid, (byte) 0xFF);

        ValidateNegotiateInfoRequest request =

            }
            // Trivial MIC: 1-byte sum of all unsigned bytes
            int sum = 0;
            for (byte b : data) {
                sum = (sum + (b & 0xFF)) & 0xFF;
            }
            return new byte[] { (byte) sum };
        }

        @Override
        public void verifyMIC(byte[] data, byte[] mic) throws CIFSException {

    @Test
    @DisplayName("Test readDataWireFormat with unsupported information level")
    void testReadDataWireFormatWithUnsupportedLevel() throws SMBProtocolDecodingException {
        byte unsupportedLevel = (byte) 0xFF;
        response = new Trans2QueryPathInformationResponse(mockConfig, unsupportedLevel);

        byte[] buffer = new byte[100];
        response.setDataCount(buffer.length);

        // Random but realistic GUID
        byte[] testGuid = { (byte) 0x01, (byte) 0x23, (byte) 0x45, (byte) 0x67, (byte) 0x89, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF,
                (byte) 0xFE, (byte) 0xDC, (byte) 0xBA, (byte) 0x98, (byte) 0x76, (byte) 0x54, (byte) 0x32, (byte) 0x10 };

        // Security mode with signing required

    byte[] quad = textToNumericFormatV4(dottedQuad);
    if (quad == null) {
      return null;
    }
    String penultimate = Integer.toHexString(((quad[0] & 0xff) << 8) | (quad[1] & 0xff));
    String ultimate = Integer.toHexString(((quad[2] & 0xff) << 8) | (quad[3] & 0xff));
    return initialPart + penultimate + ":" + ultimate;
  }

  private static byte parseOctet(String ipString, int start, int end) {

            }
            switch (sbuf[0] & 0xFF) {
            case SessionServicePacket.POSITIVE_SESSION_RESPONSE:
                if (LogStream.level >= 4) {
                    log.println("session established ok with " + address);
                }
                return;
            case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
                final int errorCode = in.read() & 0xFF;
                switch (errorCode) {