#### Blocking APIs

Blocking APIs are convenient because you get top-to-bottom procedural code without indirection. Network calls work like regular method calls: ask for data and it is returned. If the request fails, you get a stacktrace right where the call was made.

import org.junit.Ignore;

/**
 * Common superclass for {@link MultisetSetCountUnconditionallyTester} and {@link
 * MultisetSetCountConditionallyTester}. It is used by those testers to test calls to the
 * unconditional {@code setCount()} method and calls to the conditional {@code setCount()} method
 * when the expected present count is correct.
 *
 * @author Chris Povirk
 */
@GwtCompatible

    }

    @Test
    @DisplayName("getInput and getOutput throw after close")
    void testGetInputOutputAndClosed() throws CIFSException {
        // After closing the handle, further calls throw
        target.close();
        CIFSException e1 = assertThrows(SmbException.class, target::getInput);
        assertTrue(e1.getMessage().contains("Already closed"));

/**
 * A multimap which forwards all its method calls to another multimap. Subclasses should override
 * one or more methods to modify the behavior of the backing multimap as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

import com.google.common.annotations.GwtCompatible;
import java.util.Collection;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * A set which forwards all its method calls to another set. Subclasses should override one or more
 * methods to modify the behavior of the backing set as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *

/**
 * A multimap which forwards all its method calls to another multimap. Subclasses should override
 * one or more methods to modify the behavior of the backing multimap as desired per the <a
 * href="http://en.wikipedia.org/wiki/Decorator_pattern">decorator pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code

        NtlmHttpServletRequest request = new NtlmHttpServletRequest(mockRequest, mockPrincipal);
        assertEquals("NTLM", request.getAuthType());
        // Verify it returns the same value on multiple calls
        assertEquals("NTLM", request.getAuthType());
    }

    }

    /**
     * Test consistency across multiple calls
     */
    @Test
    @DisplayName("Test consistency across multiple calls")
    public void testConsistencyAcrossMultipleCalls() {
        // Given
        smbComTreeDisconnect = new SmbComTreeDisconnect(config);
        byte[] buffer = new byte[100];

        // When & Then - multiple calls should return the same result
        for (int i = 0; i < 10; i++) {

    assertTrue(Thread.holdsLock(mutex));
    return super.isEmpty();
  }

  /*
   * We don't assert that the lock is held during calls to iterator(), stream(), and spliterator:
   * `Synchronized` doesn't guarantee that it will hold the mutex for those calls because callers
   * are responsible for taking the mutex themselves:

configured to fall back for broad connectivity.

Using OkHttp is easy. Its request/response API is designed with fluent builders and immutability. It
supports both synchronous blocking calls and async calls with callbacks.

A well behaved user agent
-------------------------

OkHttp follows modern HTTP specifications such as

* HTTP Semantics - [RFC 9110](https://datatracker.ietf.org/doc/html/rfc9110)