assertNotNull(buffer2, "Second buffer should not be null");
        assertEquals(1024, buffer1.length, "Buffer should have expected size");
        assertEquals(1024, buffer2.length, "Buffer should have expected size");
        assertNotSame(buffer1, buffer2, "Different calls should return different buffers initially");
    }

    @Test

        lastWrite.setAccessible(true);
        lastWrite.setLong(resp, 1630000000000L);
        java.lang.reflect.Field size = SmbComQueryInformationResponse.class.getDeclaredField("fileSize");
        size.setAccessible(true);
        size.setInt(resp, 2048);

        assertEquals(0xABCD, resp.getAttributes());
        assertEquals(1630000001000L, resp.getCreateTime());

        element.input = unescape(parts[i++])

        val base = if (i < parts.size) parts[i++] else null
        element.base =
          when {
            base == null || base.isEmpty() -> list[list.size - 1].base
            else -> unescape(base)
          }

        while (i < parts.size) {
          val piece = parts[i]
          if (piece.startsWith("#")) {
            i++
            continue

        }
        if (size > maxSize) {
            throw new IllegalArgumentException(fieldName + " size exceeds maximum (" + maxSize + "): " + size);
        }
    }

    /**
     * Validates buffer size for SMB2/3
     *
     * @param size the buffer size to validate
     * @param fieldName the field name for error reporting
     * @throws IllegalArgumentException if size is invalid
     */

				CalculatedSHA256: sha256Hex,
			}
		}
		if r.size >= 0 && size >= 0 && r.size != size {
			return nil, SizeMismatch{Want: r.size, Got: size}
		}

		r.checksum = MD5
		r.contentSHA256 = SHA256
		if r.size < 0 && size >= 0 {
			r.src = etag.Wrap(ioutil.HardLimitReader(r.src, size), r.src)
			r.size = size
		}
		if r.actualSize <= 0 && actualSize >= 0 {
			r.actualSize = actualSize

      newDelegate.addAll(delegate);
      this.table = newDelegate;
      return;
    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask

    }

    /**
     * Set the maximum pool size
     * @param size the maximum number of connections in the pool
     */
    public void setMaxPoolSize(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("Pool size must be positive");
        }
        this.maxPoolSize = size;
        log.info("Set maximum pool size to {}", size);
    }

    /**

        expectedSize += ((nameLen + 7) / 8) * 8; // size8(nameLen)
        expectedSize = ((expectedSize + 7) / 8) * 8; // size8(size)

        assertEquals(expectedSize, request.size());
    }

    @Test
    @DisplayName("Test size calculation with empty path")
    void testSizeWithEmptyPath() {
        request = new Smb2CreateRequest(mockConfig, "");

     */
    public void setIndex(final String index) {
        this.index = index;
    }

    /**
     * Sets the size of results.
     * @param size The size.
     */
    public void setSize(final int size) {
        this.size = size;
    }

    /**
     * Sets the query string.
     * @param query The query string.
     */
    public void setQuery(final String query) {

  private void assertCollectionSize(Collection<?> collection, int size) {
    assertThat(collection.size()).isEqualTo(size);
    if (size > 0) {
      assertThat(collection.isEmpty()).isFalse();
    } else {
      assertThat(collection.isEmpty()).isTrue();
    }
    assertThat(Iterables.size(collection)).isEqualTo(size);
    assertThat(Iterators.size(collection.iterator())).isEqualTo(size);
  }