}

    /**
     * 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) {

    @DisplayName("Should return max transact size")
    void testGetMaxTransactSize() throws Exception {
        // Given
        setPrivateField(response, "maxTransactSize", 1048576);

        // When
        int size = response.getMaxTransactSize();

        // Then
        assertEquals(1048576, size);
    }

    @Test
    @DisplayName("Should return transaction buffer size")

            // 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;

    /**
     * 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

    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());
  }

}

/**
 * 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

    @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);

  //      after: { 11, 11, 22, 22, 33, 33, 00, 00, 00, 00, 00, 00, 77, 77, 88, 88 }
  //
  if (b != address.size) {
    if (compress == -1) return null // Address didn't have compression or enough groups.
    address.copyInto(address, address.size - (b - compress), compress, b)
    address.fill(0.toByte(), compress, compress + (address.size - b))
  }

  return address
}

      assertThat(expected.message).isEqualTo(
        "Payload size must be less than or equal to 125",
      )
    }
  }

  private fun assertData(hex: String) {
    assertData(hex.decodeHex())
  }

  private fun assertData(expected: ByteString) {
    val actual = data.readByteString(Math.min(expected.size.toLong(), data.size))
    assertThat(actual).isEqualTo(expected)
  }

  companion object {