assertNotNull(result);
        assertTrue(result instanceof List);
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> resultList = (List<Map<String, Object>>) result;
        assertEquals(2, resultList.size());

        Map<String, Object> map1 = resultList.get(0);
        assertEquals("name1", map1.get("name"));

        Map<String, Object> map2 = resultList.get(1);
        assertEquals("name2", map2.get("name"));

            throw new RuntimeException(e);
        }

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 40 + inputBuffer.size())
        int expectedRawSize = Smb2Constants.SMB2_HEADER_LENGTH + 40 + 100;
        int expectedSize = (expectedRawSize + 7) & ~7;
        assertEquals(expectedSize, size);
    }

    @Test

    rowKeyToIndex = table.rowKeyToIndex;
    columnKeyToIndex = table.columnKeyToIndex;
    @SuppressWarnings("unchecked")
    @Nullable V[][] copy = (@Nullable V[][]) new Object[rowList.size()][columnList.size()];
    array = copy;
    for (int i = 0; i < rowList.size(); i++) {
      arraycopy(table.array[i], 0, copy[i], 0, table.array[i].length);
    }
  }

  private abstract static class ArrayMap<K, V extends @Nullable Object>

        // Write structure size (4) at offset
        SMBUtil.writeInt2(4, buffer, offset);
        SMBUtil.writeInt2(0, buffer, offset + 2); // Reserved field

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesRead);
    }

    @DisplayName("Should throw exception for invalid structure size")
    @ParameterizedTest

    @Mock
    Configuration cfg;

    // Verifies constructor that accepts Configuration reads the expected values and uses them
    @Test
    @DisplayName("Constructor(Configuration) uses cache size and maximum buffer size from config")
    void constructorUsesConfigurationAndAllocatesWithConfiguredSize() {
        when(cfg.getBufferCacheSize()).thenReturn(2);
        when(cfg.getMaximumBufferSize()).thenReturn(5);

        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;
        assertTrue(boolResult.hasClauses());
        assertEquals(1, boolResult.must().size());
        assertEquals(1, boolResult.should().size());
        assertEquals(1, boolResult.mustNot().size());
    }

    // Test convertBooleanQuery with empty BooleanQuery
    public void test_convertBooleanQuery_withEmptyQuery() {

func NewReader(r io.ReaderAt, size int64) (*Reader, error) {
	if size < 0 {
		return nil, errors.New("zip: size cannot be negative")
	}
	zr := new(Reader)
	var err error
	if err = zr.init(r, size); err != nil && err != ErrInsecurePath {
		return nil, err
	}
	return zr, err
}

func (r *Reader) init(rdr io.ReaderAt, size int64) error {
	end, baseOffset, err := readDirectoryEnd(rdr, size)

        assertEquals(5, itemList1.size());
        assertEquals(5, itemList1.getAllRecordCount());
        assertEquals(1, itemList1.getCurrentPageNumber());
        assertEquals(20, itemList1.getPageSize());

        final PagingList<SynonymItem> itemList2 = synonymFile.selectList(4, 2);
        assertEquals(1, itemList2.size());
        assertEquals(5, itemList2.getAllRecordCount());

    int RC4_ENC_TYPE = 23;
    /** RC4 algorithm name */
    String RC4_ALGORITHM = "ARCFOUR";
    /** HMAC algorithm name */
    String HMAC_ALGORITHM = "HmacMD5";
    /** Size of confounder in bytes */
    int CONFOUNDER_SIZE = 8;
    /** Size of checksum in bytes */
    int CHECKSUM_SIZE = 16;

    }

    /**
     * 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);
    }

    /**