byte[] col2 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x81};
    byte[] col3 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0xff};

    ImmutableSet<HashCode> hashCodes =
        ImmutableSet.of(
            SIP_WITH_KEY.hashBytes(col1),
            SIP_WITH_KEY.hashBytes(col2),
            SIP_WITH_KEY.hashBytes(col3));

                    lock.wait();
                }
            } catch (final InterruptedException ie) {
                throw new IOException(ie.getMessage());
            }
            result = pipe_buf[beg_idx] & 0xFF;
            beg_idx = (beg_idx + 1) % pipe_buf.length;
        }
        return result;
    }

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

        assertEquals("fine", tokens.get(7).getTerm());
    }

    @Test
    public void testAnalyzeWithNumbers() {
        // Test analyze with numbers
        String text = "123 456.789 0xFF 3.14159";
        String field = "content";
        String lang = "en";

        List<AnalyzeToken> tokens = analyzer.analyze(text, field, lang);

        assertNotNull(tokens);

    public void enc_ndr_small(final int s) {
        this.buf[this.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 = this.buf[this.index] & 0xFF;
        advance(1);
        return val;
    }

    /**

	formatZstd
	formatLZ4
	formatS2
	formatBZ2
)

var magicHeaders = []struct {
	header []byte
	f      format
}{
	{
		header: []byte{0x1f, 0x8b, 8},
		f:      formatGzip,
	},
	{
		// Zstd default header.
		header: []byte{0x28, 0xb5, 0x2f, 0xfd},
		f:      formatZstd,
	},
	{
		// Zstd skippable frame header.
		header: []byte{0x2a, 0x4d, 0x18},
		f:      formatZstd,
	},
	{
		// LZ4

            byte[] buffer = new byte[200];
            // Fill buffer with pattern to ensure proper writing
            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) 0xFF;
            }

            int bytesEncoded = request.encode(buffer, offset);

            // Verify data at correct offset
            assertEquals(timeout, SMBUtil.readInt8(buffer, offset));

      }

      while (!encodedCharBuffer.exhausted()) {
        val b = encodedCharBuffer.readByte().toInt() and 0xff
        writeByte('%'.code)
        writeByte(HEX_DIGITS[b shr 4 and 0xf].code)
        writeByte(HEX_DIGITS[b and 0xf].code)
      }
    } else {
      // This character doesn't need encoding. Just copy it over.
      writeUtf8CodePoint(codePoint)
    }

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

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

        dataOffset = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        dataDisplacement = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        setupCount = buffer[bufferIndex] & 0xFF;
        bufferIndex += 2;
        if ((setupCount != 0) && (LogStream.level > 2)) {
            log.println("setupCount is not zero: " + setupCount);
        }

        return bufferIndex - start;
    }

     */
    private static byte[] newBuffer(int length) {
        // initialise with distinct pattern to detect unused trailing bytes
        byte[] buf = new byte[length];
        Arrays.fill(buf, (byte) 0xFF);
        return buf;
    }

    @Test
    @DisplayName("constructor initialises command and parameters correctly")
    void testConstructorInitialisesFields() throws Exception {
        int level = 42;