}

    for (int i = 0; i < 10; i++) {
      loader.reset();
      assertEquals(Integer.valueOf(VALUE_PREFIX + i), cache.getUnchecked(KEY_PREFIX + i));
      assertFalse("Creator should not have been called @#" + i, loader.wasCalled());
    }

    CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);

    assertEquals("Map must be empty by now", 0, cache.size());

    @Test
    public void testParamWithNullValue() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        CurlRequest result = request.param("key", null);

        assertSame(request, result); // Should not add null parameters
    }

    @Test
    public void testHeaderMethod() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

 *
 * <p>{@code CharSink} provides two kinds of methods:
 *
 * <ul>
 *   <li><b>Methods that return a writer:</b> These methods should return a <i>new</i>, independent
 *       instance each time they are called. The caller is responsible for ensuring that the
 *       returned writer is closed.
 *   <li><b>Convenience methods:</b> These are implementations of common operations that are

        // Match by share name or server address, safely handling nulls
        boolean shareMatch = resourceName != null && shareName != null && resourceName.equalsIgnoreCase(shareName);

        String serverAddress = registration.getServerAddress() != null ? registration.getServerAddress().getHostAddress() : null;
        boolean addressMatch = java.util.Objects.equals(resourceName, serverAddress);

 * controls the order in which events are dispatched, while the executor controls how (i.e. on which
 * thread) the subscriber is actually called when an event is dispatched to it.
 *
 * @author Colin Decker
 */
abstract class Dispatcher {

  /**
   * Returns a dispatcher that queues events that are posted reentrantly on a thread that is already

   */
  public void add(Runnable runnable, Executor executor) {
    // Fail fast on a null. We throw NPE here because the contract of Executor states that it throws
    // NPE on null listener, so we propagate that contract up into the add method as well.
    checkNotNull(runnable, "Runnable was null.");
    checkNotNull(executor, "Executor was null.");

    // Lock while we check state. We must maintain the lock while adding the new pair so that

  }

  @Override
  public Iterator<E> iterator() {
    if (iterator == null) {
      // TODO: throw something else? Do we worry that people's code and tests
      // might be relying on this particular type of exception?
      throw new IllegalStateException();
    }
    try {
      return iterator;
    } finally {
      iterator = null;
    }
  }

        // When & Then - verify interface methods exist and can be called
        assertDoesNotThrow(() -> {
            cache.getBuffer();
            cache.releaseBuffer(new byte[1024]);
        }, "All BufferCache interface methods should be callable");
    }

    @Test
    @DisplayName("getBuffer should return non-null byte array")
    void testGetBufferContract() {
        // Given

   * and then applying {@code function} to that value. Note that the resulting supplier will not
   * call {@code supplier} or invoke {@code function} until it is called.
   */
  public static <F extends @Nullable Object, T extends @Nullable Object> Supplier<T> compose(
      Function<? super F, T> function, Supplier<F> supplier) {
    return new SupplierComposition<>(function, supplier);
  }

     */
    @Override
    public boolean equals(final Object obj) {
        return obj instanceof UniAddress && this.addr.equals(((UniAddress) obj).addr);
    }

    /**
     * Guess first called name to try for session establishment. This
     * method is used exclusively by the <code>jcifs.smb</code> package.
     *
     * @return the guessed name
     */
    @Override
    public String firstCalledName() {