import okhttp3.EventListener
import okhttp3.Handshake
import okhttp3.HttpUrl
import okhttp3.Protocol
import okhttp3.Route
import okhttp3.internal.http.RealInterceptorChain

/**
 * A connection user that is a specific [RealCall].
 */
internal class CallConnectionUser(
  private val call: RealCall,
  private val poolConnectionListener: ConnectionListener,
  private val chain: RealInterceptorChain,
) : ConnectionUser {

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.io.Serializable;
import java.util.Iterator;
import org.jspecify.annotations.Nullable;

/** An ordering that uses the reverse of a given order. */
@GwtCompatible
final class ReverseOrdering<T extends @Nullable Object> extends Ordering<T>
    implements Serializable {
  final Ordering<? super T> forwardOrder;

   * will return {@code Double.MAX_VALUE}, not {@code Double.POSITIVE_INFINITY}.
   *
   * <p>For the case of {@link RoundingMode#HALF_EVEN}, this implementation uses the IEEE 754
   * default rounding mode: if the two nearest representable values are equally near, the one with
   * the least significant bit zero is chosen. (In such cases, both of the nearest representable

/**
 * Implementation of {@link ImmutableMap} with exactly one entry.
 *
 * @author Jesse Wilson
 * @author Kevin Bourrillion
 */
@GwtCompatible
@SuppressWarnings("serial") // uses writeReplace(), not default serialization
final class SingletonImmutableBiMap<K, V> extends ImmutableBiMap<K, V> {

  final transient K singleKey;
  final transient V singleValue;

    /**
     * Checks if SMB message signing is active for this session
     * @return whether the session uses SMB signing
     * @throws CIFSException if a general CIFS error occurs
     * @throws SmbException if an SMB-specific error occurs
     */
    boolean areSignaturesActive() throws CIFSException;

    /**
     * Internal/testing use only
     *
     * @return attached session
     */
    SmbSession getSession();

### Valores de retorno

Y pueden devolver valores o no, los valores no serán usados.

Así que, puedes reutilizar una dependencia normal (que devuelve un valor) que ya uses en otro lugar, y aunque el valor no se use, la dependencia será ejecutada:

{* ../../docs_src/dependencies/tutorial006_an_py39.py hl[11,16] *}

## Dependencias para un grupo de *path operations*

 * </p>
 *
 * <p>
 * Example usage:
 * </p>
 * <pre>
 * {@code
 * AuthScope authScope = new AuthScope("example.com", 80);
 * Credentials credentials = new UsernamePasswordCredentials("user", "password");
 * AuthenticationImpl auth = new AuthenticationImpl(authScope, credentials);
 * }
 * </pre>
 *
 * @see org.codelibs.fess.crawler.client.http.Authentication
 */

        SmbException ex = assertThrows(SmbException.class, handle::ensureOpen);
        assertTrue(ex.getMessage().contains("Pipe handle already closed"));
    }

    @Test
    @DisplayName("sendrecv uses SMB2 ioctl when tree is SMB2")
    void sendrecv_smb2_ioctl() throws Exception {
        // Arrange
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\x");

        resolver.resolve(SamlCredential.class, credential -> OptionalEntity.of(credential.getUser()));
    }

    @Override
    public String logout(final FessUserBean user) {
        if (user.getFessUser() instanceof SamlUser) {
            return LaRequestUtil.getOptionalRequest().map(request -> {
                if (logger.isDebugEnabled()) {

import jcifs.smb1.Config;

/**
 * Buffer cache implementation for SMB1 protocol operations.
 * Manages a pool of byte buffers to reduce garbage collection overhead.
 *
 * Performance optimizations:
 * - Uses ConcurrentLinkedQueue for O(1) operations
 * - Lock-free operations for better concurrency
 * - Proper buffer validation and limits
 */
public class BufferCache {

    /**