.addEqualityGroup(isNull)
        .addEqualityGroup(Equivalence.identity().equivalentTo("1"))
        .testEquals();
  }

  /*
   * We use large numbers to avoid the integer cache. Normally, we'd accomplish that merely by using
   * `new Integer` (as we do) instead of `Integer.valueOf`. However, under J2KT, `new Integer`

   * typically useful for {@code return} statements. That leaves the code with two options: Either
   * add the suppression to the whole method (which turns off checking for a large section of code),
   * or extract a variable, and put the suppression on that. However, a local variable typically
   * doesn't work: Because nullness analyses typically infer the nullness of local variables,

            // Should not throw when converting to byte array
            assertDoesNotThrow(() -> init.toByteArray());
        }

        @Test
        @DisplayName("Large MIC values are handled correctly")
        void testLargeMicValue() throws Exception {
            byte[] largeMic = new byte[1024];
            Arrays.fill(largeMic, (byte) 0xAB);

        assertEquals(1L, crawlerContext.decrementAndGetAccessCount());

        // Test large increments
        for (int i = 0; i < 1000; i++) {
            crawlerContext.incrementAndGetAccessCount();
        }
        assertEquals(1001L, crawlerContext.getAccessCount());

        // Test large decrements
        for (int i = 0; i < 500; i++) {
            crawlerContext.decrementAndGetAccessCount();

	// This test compares byte slices that are almost identical, except one
	// difference that for some j, a[j]>b[j] and a[j+1]<b[j+1]. If the implementation
	// compares large chunks with wrong endianness, it gets wrong result.
	// no vector register is larger than 512 bytes for now
	const maxLength = 512
	a := make([]byte, maxLength)
	b := make([]byte, maxLength)
	// randomish but deterministic data. No 0 or 255.

   * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is
   * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large
   * replacement mappings.
   *
   * <p>If a character has no mapped replacement then it is checked against the safe range. If it
   * lies outside that, then {@link #escapeUnsafe} is called, otherwise no escaping is performed.

        FileBothDirectoryInfo result = (FileBothDirectoryInfo) createFileInfoMethod.invoke(response);

        assertNull(result);
    }

    @Test
    @DisplayName("Test readBytesWireFormat handles large buffer offset correctly")
    void testReadBytesWireFormatLargeBufferOffset() throws Exception {
        response = new Smb2QueryDirectoryResponse(mockConfig, Smb2QueryDirectoryRequest.FILE_BOTH_DIRECTORY_INFO);

    }

    /**
     * Test edge case with maximum data size
     */
    @Test
    @DisplayName("Handle large data size")
    void testLargeDataSize() throws CIFSException {
        // Create a large data array
        byte[] largeData = new byte[1024];
        Arrays.fill(largeData, (byte) 0xFF);

        byte[] avPairData = createAvPairData(0x99, largeData);

 *     process(part.headers, part.body)
 *   }
 * }
 * ```
 *
 * Note that [nextPart] will skip any unprocessed data from the preceding part. If the preceding
 * part is particularly large or if the underlying source is particularly slow, the [nextPart] call
 * may be slow!
 *
 * Closing a part **does not** close this multipart reader; callers must explicitly close this with
 * [close].
 *

   * response body. Call `body.source().request(1024 * 1024)` to block until either that's done, or
   * 1 MiB of response data is loaded into memory. (You could use any size here, though large values
   * risk exhausting memory.)
   *
   * This returns an empty value if the trailers are available, but have no data.
   *