}

        DfsReferralDataInternal dr = null;
        final long now = System.currentTimeMillis();
        synchronized (this.domainsLock) {
            /*
             * domains that can contain DFS points to maps of roots for each
             */
            final Map<String, Map<String, CacheEntry<DfsReferralDataInternal>>> domains = getTrustedDomains(tf);
            if (domains != null) {

   * </ol>
   *
   * @param multimap the presumed-immutable multimap
   * @param sampleKey a key of the same type as that contained by {@code multimap}. {@code multimap}
   *     may or may not have {@code sampleKey} as a key.
   * @param sampleValue a key of the same type as that contained by {@code multimap}. {@code
   *     multimap} may or may not have {@code sampleValue} as a key.
   */

        next = getNext(entry);
      } while (next != UNSET);
      entries[last] = swapNext(entry, newEntryIndex);
    }
    if (newEntryIndex == Integer.MAX_VALUE) {
      throw new IllegalStateException("Cannot contain more than Integer.MAX_VALUE elements!");
    }
    int newSize = newEntryIndex + 1;
    resizeMeMaybe(newSize);
    insertEntry(newEntryIndex, key, value, hash);
    this.size = newSize;

                assertNotNull(targetInfo);
                // Should only contain server info - but might have different structure than expected
                assertTrue(targetInfo.length >= 4, "Target info should have at least terminator");
                // Check if it contains server info (implementation dependent)
                if (targetInfo.length > 4) {

            return Result.error(Collections.singletonList(new DefaultModelProblem(null, null, null, null, 0, 0, e)));
        } catch (final CycleDetectedException e) {
            String message = "The projects in the reactor contain a cyclic reference: " + e.getMessage();
            ProjectCycleException error = new ProjectCycleException(message, e);
            return Result.error(

     */
    public jcifs.internal.smb2.persistent.HandleGuid getDurableHandleGuid() {
        // For now, return null as the GUID is typically provided in the request context
        // and the response doesn't necessarily contain the GUID in a standard format
        return null;
    }

      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Object key = warmed.get(i - WARMUP_MIN).getKey();
        assertThat(keys.contains(key)).isTrue();
        assertThat(keys.remove(key)).isTrue();
        assertThat(keys.remove(key)).isFalse();
        assertThat(keys.contains(key)).isFalse();
      }
      checkEmpty(keys);
      checkEmpty(cache);
    }
  }

  public void testValues_populated() {

            sendBuffer.getBuffer().put(testData);
            sendBuffer.getBuffer().flip();
            assertEquals(testData.length, sendBuffer.getBuffer().remaining(), "Buffer should contain test data");

            // Clean up
            bufferManager.releaseSendRegion(sendBuffer);
            bufferManager.releaseReceiveRegion(recvBuffer);

    boolean contained = false;
    if (actual instanceof Collection) {
      contained = ((Collection<?>) actual).contains(expected);
    } else {
      for (Object o : actual) {
        if (equal(o, expected)) {
          contained = true;
          break;
        }
      }
    }

    if (!contained) {
      fail("Not true that " + actual + " contains " + expected);

  classpath = compileKotlinTask.libraries
  modularity.inferModulePath.set(true)
}

// Call the convention when the task has finished, to modify the jar to contain OSGi metadata.
tasks.named<Jar>("jvmJar").configure {
  manifest {
    attributes(
      "Multi-Release" to true,
    )
  }

  from(compileJavaModuleInfo.get().destinationDirectory) {