* Converts byte count to human-readable size format.
     *
     * @param size the size in bytes
     * @return formatted size string
     */
    public static String byteCountToDisplaySize(final long size) {
        return byteCountToDisplaySize(BigInteger.valueOf(size));
    }

    private static String byteCountToDisplaySize(final BigInteger size) {
        Objects.requireNonNull(size, "size");
        final String displaySize;

    }

    /**
     * Gets the page size.
     * @return The page size.
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the page size.
     * @param pageSize The page size.
     */
    public void setPageSize(final int pageSize) {

            // When
            int size = copy.size();

            // Then
            assertEquals(HEADER_SIZE, size);
        }

        @Test
        @DisplayName("Should return correct size with single chunk")
        void testSizeWithSingleChunk() {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];

        byte[] buffer = new byte[104]; // Exact size needed
        int offset = 0;

        setHeaderStart(response, 64);

        // Write structure
        SMBUtil.writeInt2(9, buffer, offset);
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2);
        SMBUtil.writeInt4(24, buffer, offset + 4); // Exact notification size

        // Write notification
        int notifyOffset = 80;

    return create(e1, e2, e3, e4, e5);
  }

  @SuppressWarnings("unchecked")
  public static <E> ImmutableSet<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E... others) {
    int size = others.length + 6;
    List<E> all = new ArrayList<E>(size);
    Collections.addAll(all, e1, e2, e3, e4, e5, e6);
    Collections.addAll(all, others);
    return copyOf(all.iterator());
  }

     * @return a hexadecimal string representation of the byte array
     */
    public static String toHexString(final byte[] src, final int srcIndex, int size) {
        final char[] c = new char[size];
        size = size % 2 == 0 ? size / 2 : size / 2 + 1;
        for (int i = 0, j = 0; i < size; i++) {
            c[j] = HEX_DIGITS[src[i] >> 4 & 0x0F];
            j++;
            if (j == c.length) {
                break;

}

/**
 * Modifies [ranges] to combine any adjacent [MappedRange.InlineDelta] of same size to single entry.
 * @returns same instance of [ranges] for convenience
 */
internal fun mergeAdjacentDeltaMappedRanges(ranges: MutableList<MappedRange>): MutableList<MappedRange> {
  var i = 0
  while (i < ranges.size) {
    val curr = ranges[i]
    if (curr is MappedRange.InlineDelta) {
      val j = i + 1

            // Negative values will be cast to unsigned when encoded
            assertEquals(4 + 2 * path.length(), buffer.size());
        }
    }

    @Nested
    @DisplayName("Size Calculation Tests")
    class SizeTests {

        @ParameterizedTest
        @DisplayName("Should calculate correct size for various path lengths")

    /**
     * Default maximum receive size (8KB)
     */
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;

    /**
     * Default maximum fragmented size (128KB)
     */
    public static final int DEFAULT_MAX_FRAGMENTED_SIZE = 131072; // 128KB

    /**
     * Default maximum read/write size (1MB)
     */
    public static final int DEFAULT_MAX_READ_WRITE_SIZE = 1048576; // 1MB

    @Test
    @DisplayName("Test readBytesWireFormat with valid structure size")
    void testReadBytesWireFormatValidStructureSize() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

        byte[] buffer = new byte[512];
        int bufferIndex = 0;

        // Set structure size to 9 (valid)
        SMBUtil.writeInt2(9, buffer, bufferIndex);