inbound: Boolean,
    streamId: Int,
    length: Int,
    type: Int,
    flags: Int,
  ): String {
    val formattedType = formattedType(type)
    val formattedFlags = formatFlags(type, flags)
    val direction = if (inbound) "<<" else ">>"
    return format(
      "%s 0x%08x %5d %-13s %s",
      direction,
      streamId,
      length,
      formattedType,
      formattedFlags,
    )
  }

                ip = i = 0;
                for (; i < data.length && c == '.'; i++) {
                    int b = 0x00;

                    for (; i < data.length && (c = data[i]) >= 48 && c <= 57; i++) {
                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;

        byte[] actualDescrBytes = new byte[expectedDescrBytes.length];
        System.arraycopy(dst, 2, actualDescrBytes, 0, expectedDescrBytes.length);
        assertArrayEquals(expectedDescrBytes, actualDescrBytes);

        // Verify level (0x0001 - 2 bytes)
        int descrEnd = 2 + expectedDescrBytes.length;
        assertEquals(0x01, dst[descrEnd]);
        assertEquals(0x00, dst[descrEnd + 1]);

        // Prepare test data with zeros
        byte[] buffer = new byte[22];

        // All zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = 0;
        }

        // Decode
        smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - all zeros should result in 0 capacity and free
        assertEquals(0L, smbInfoAllocation.getCapacity());

      return seq.toString();
    }

    @Override
    public boolean isEmpty() {
      return seq.length() == 0;
    }

    @Override
    public long length() {
      return seq.length();
    }

    @Override
    public Optional<Long> lengthIfKnown() {
      return Optional.of((long) seq.length());
    }

    /**

      return seq.toString();
    }

    @Override
    public boolean isEmpty() {
      return seq.length() == 0;
    }

    @Override
    public long length() {
      return seq.length();
    }

    @Override
    public Optional<Long> lengthIfKnown() {
      return Optional.of((long) seq.length());
    }

    /**

            return new SuggestIndexResponse(items.length, items.length, result.getFailures(), System.currentTimeMillis() - start);
        } catch (final Exception e) {
            throw new SuggestIndexException("Failed to write items[" + items.length + "] to " + index, e);
        }
    }

    /**
     * Deletes a suggest item by ID.

        byte[] buf = new byte[10];
        assertEquals(0, cmd.readSetupWireFormat(buf, 0, buf.length));
        assertEquals(0, cmd.readParametersWireFormat(buf, 0, buf.length));
        assertEquals(0, cmd.readDataWireFormat(buf, 0, buf.length));
    }

    @ParameterizedTest
    @CsvSource({ "0, 0", // all zeros
            "-1, 2147483647", // negative fid, max positive security

    }

    static int writeSecurityBuffer(final byte[] dest, final int offset, final byte[] src) {
        final int length = src != null ? src.length : 0;
        if (length == 0) {
            return offset + 4;
        }
        writeUShort(dest, offset, length);
        writeUShort(dest, offset + 2, length);
        return offset + 4;
    }

    return CompactHashSet.create();
  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we