@Override
      <E extends @Nullable Object> int resultIndex(
          Comparator<? super E> comparator,
          @ParametricNullness E key,
          List<? extends E> list,
          int foundIndex) {
        // Of course, we have to use binary search to find the precise
        // breakpoint...
        int lower = foundIndex;
        int upper = list.size() - 1;

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

        pos += 8;
        final int userOff = writeSecurityBuffer(type3, 36, userBytes);
        pos += 8;
        final int wsOff = writeSecurityBuffer(type3, 44, workstationBytes);
        pos += 8;
        final int skOff = writeSecurityBuffer(type3, 52, sessionKeyBytes);
        pos += 8;

        writeULong(type3, pos, getFlags());
        pos += 4;

    @Test
    void testGetLocalGroupsMap_LargeGroupMembership() throws CIFSException {
        Map<SID, List<SID>> largeMap = new HashMap<>();
        for (int i = 0; i < 100; i++) {
            SID groupSid = mock(SID.class);
            List<SID> members = new ArrayList<>();
            for (int j = 0; j < 50; j++) {
                members.add(mock(SID.class));
            }
            largeMap.put(groupSid, members);
        }

        void testSignThreadSafety() throws InterruptedException {
            int threadCount = 10;
            Thread[] threads = new Thread[threadCount];
            byte[][] dataArrays = new byte[threadCount][128];

            for (int i = 0; i < threadCount; i++) {
                final int index = i;
                dataArrays[i] = new byte[128];
                Arrays.fill(dataArrays[i], (byte) i);

	if cardinality <= 0 {
		return -1
	}
	keyCrc := crc32.Checksum([]byte(key), crc32.IEEETable)
	return int(keyCrc % uint32(cardinality))
}

func hashKey(algo string, key string, cardinality int, id [16]byte) int {
	switch algo {
	case formatErasureVersionV2DistributionAlgoV1:
		return crcHashMod(key, cardinality)
	case formatErasureVersionV3DistributionAlgoV2, formatErasureVersionV3DistributionAlgoV3:

        byte[] buffer = new byte[1000];
        int numThreads = 10;
        Thread[] threads = new Thread[numThreads];

        // When - multiple threads calling methods simultaneously
        for (int i = 0; i < numThreads; i++) {
            final int threadIndex = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    int offset = threadIndex * 10;

                    "WINERR_CODES and WINERR_MESSAGES should have the same length");
        }

        @Test
        void messagesAlignWithCodes() {
            for (int i = 0; i < WinError.WINERR_CODES.length; i++) {
                int code = WinError.WINERR_CODES[i];
                String message = WinError.WINERR_MESSAGES[i];
                assertNotNull(message, String.format("Message for code %d should not be null", code));

        // Given
        RequestWithFileId request = new Smb2CloseRequest(mockConfig, emptyFileId);
        int threadCount = 10;
        Thread[] threads = new Thread[threadCount];

        // When - multiple threads call setFileId concurrently
        for (int i = 0; i < threadCount; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                byte[] threadFileId = new byte[16];

  @Override public Socket createSocket(String host, int port) throws IOException {
    Socket result = createSocket();

    try {
      result.connect(new InetSocketAddress(host, port));
    } catch (IOException e) {
      result.close();
      throw e;
    }
    return result;
  }

  @Override public Socket createSocket(
      String host, int port, InetAddress localHost, int localPort) throws IOException {