TYPE_RST_STREAM -> readRstStream(handler, length, flags, streamId)
      TYPE_SETTINGS -> readSettings(handler, length, flags, streamId)
      TYPE_PUSH_PROMISE -> readPushPromise(handler, length, flags, streamId)
      TYPE_PING -> readPing(handler, length, flags, streamId)
      TYPE_GOAWAY -> readGoAway(handler, length, flags, streamId)
      TYPE_WINDOW_UPDATE -> readWindowUpdate(handler, length, flags, streamId)

        }
        return compress(data, 0, data.length, algorithm);
    }

    @Override
    public byte[] compress(byte[] data, int offset, int length, int algorithm) throws CIFSException {
        if (data == null) {
            throw new CIFSException("Data cannot be null");
        }
        if (offset < 0 || length < 0 || offset + length > data.length) {
            throw new CIFSException("Invalid offset or length");

     * @param pointer the pointer/offset to the string data
     */
    public PacUnicodeString(final short length, final short maxLength, final int pointer) {
        this.length = length;
        this.maxLength = maxLength;
        this.pointer = pointer;
    }

    /**
     * Gets the actual length of the string in bytes.
     *
     * @return the string length
     */
    public short getLength() {

      val byteCount = hpackBuffer.size
      val length = minOf(maxFrameSize - 4L, byteCount).toInt()
      frameHeader(
        streamId = streamId,
        length = length + 4,
        type = TYPE_PUSH_PROMISE,
        flags = if (byteCount == length.toLong()) FLAG_END_HEADERS else 0,
      )
      sink.writeInt(promisedStreamId and 0x7fffffff)
      sink.write(hpackBuffer, length.toLong())

        assertEquals(2, protocolHelper.getWebProtocols().length);
        assertEquals(3, protocolHelper.getFileProtocols().length);
    }

    @Test
    public void test_loadProtocols() {
        final ProtocolHelper protocolHelper = new ProtocolHelper();
        protocolHelper.loadProtocols("org.codelibs.fess.test.net.protocol");

        assertEquals(1, protocolHelper.getWebProtocols().length);

        // Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content
        assertArrayEquals(new byte[] { (byte) 0xFF, 0x01, 0x02, 0x03, 0x00 }, dest, "Encoded bytes should be placed at the correct offset");
    }

    @Test
    void testEncodeZeroLength() {
        // Test encoding with zero length
        byte[] data = { 0x01, 0x02, 0x03 };

        assertEquals((testStringTrue.length() + 1) * 2, unicodeStringTrue.length, "Length should include zterm");
        assertEquals((testStringTrue.length() + 1) * 2, unicodeStringTrue.maximum_length, "Maximum length should include zterm");
        assertNotNull(unicodeStringTrue.buffer, "Buffer should not be null");
        assertEquals(testStringTrue.length() + 1, unicodeStringTrue.buffer.length, "Buffer length should include zterm");

        }

        if (length < 0) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();
            throw new SmbException("Negative length: " + length);
        }

        // Check for integer overflow
        if (offset > buffer.length - length) {
            failedValidations.incrementAndGet();

      result = murmurHash64WithSeed(bytes, offset, length, K0 ^ K1 ^ K2);
    } else if (length <= 64) {
      result = hashLength33To64(bytes, offset, length);
    } else {
      result = fullFingerprint(bytes, offset, length);
    }

    long u = length >= 8 ? load64(bytes, offset) : K0;
    long v = length >= 9 ? load64(bytes, offset + length - 8) : K0;
    result = hash128to64(result + v, u);

   */
  static @Nullable Object[] copyAsObjectArray(@Nullable Object[] elements, int offset, int length) {
    checkPositionIndexes(offset, offset + length, elements.length);
    if (length == 0) {
      return new Object[0];
    }
    @Nullable Object[] result = new Object[length];
    arraycopy(elements, offset, result, 0, length);
    return result;
  }

  @CanIgnoreReturnValue