assertEquals(42, available, "Should return available bytes reported by SMB1 peek");

        verify(fd, never()).markClosed();
    }

    @Test
    @DisplayName("available() wraps SmbException to IOException")
    void available_wrapsException() throws Exception {
        // Verify exceptions from th.send are converted to IOException via seToIoe

  fun run() {
    // Launch wireshark in the background
    val process = eventListenerFactory.launchWireShark()

    val fbRequest =
      Request
        .Builder()
        .url("https://graph.facebook.com/robots.txt?s=fb")
        .build()
    val twitterRequest =
      Request
        .Builder()
        .url("https://api.twitter.com/robots.txt?s=tw")
        .build()
    val googleRequest =

 * ListenableFuture}</a>.
 *
 * <p>This class is GWT-compatible.
 *
 * <h3>Purpose</h3>
 *
 * <p>The main purpose of {@code ListenableFuture} is to help you chain together a graph of
 * asynchronous operations. You can chain them together manually with calls to methods like {@link
 * Futures#transform(ListenableFuture, com.google.common.base.Function, Executor) Futures.transform}

import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.RepositorySystemSession.CloseableSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.graph.DependencyFilter;
import org.eclipse.aether.internal.impl.DefaultChecksumPolicyProvider;
import org.eclipse.aether.internal.impl.DefaultRemoteRepositoryManager;

 * Thread2: acquire(LockB) --X acquire(LockC)
 * ...
 * ThreadN: acquire(LockN) --X acquire(LockA)
 * </pre>
 *
 * <p>The implementation detects cycles by constructing a directed graph in which each lock
 * represents a node and each edge represents an acquisition ordering between two locks.
 *
 * <ul>
 *   <li>Each lock adds (and removes) itself to/from a ThreadLocal Set of acquired locks when the

        queryContext.addQuery(boolQuery -> {
            // Don't add any clauses
        });

        // When no clauses are added to a non-MatchAllQuery, it still wraps in BoolQuery
        QueryBuilder result = queryContext.getQueryBuilder();
        assertTrue(result instanceof BoolQueryBuilder);
        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;

  }

  /**
   * Sets.cartesianProduct doesn't allow sets that contain null, but we want null to mean "don't
   * call the associated CacheBuilder method" - that is, get the default CacheBuilder behavior. This
   * method wraps the elements in the input sets (which may contain null) as Optionals, calls
   * Sets.cartesianProduct with those, then transforms the result to unwrap the Optionals.
   */

	c.mu.Lock()
	defer c.mu.Unlock()
	c.abortWrites.Store(!t.IsZero() && time.Until(t) < 0)
	c.infWrites.Store(t.IsZero())
	c.writeSetAt = time.Time{}
	return c.Conn.SetWriteDeadline(t)
}

// Close wraps conn.Close and stops sending deadline updates.
func (c *DeadlineConn) Close() error {
	c.abortReads.Store(true)
	c.abortWrites.Store(true)
	return c.Conn.Close()
}

}

func (u *uaTransport) RoundTrip(req *http.Request) (*http.Response, error) {
	req2 := req.Clone(req.Context())
	req2.Header.Set("User-Agent", u.ua)
	return u.rt.RoundTrip(req2)
}

// WithUserAgent wraps an existing transport with custom User-Agent
func WithUserAgent(rt http.RoundTripper, getUA func() string) http.RoundTripper {
	return &uaTransport{
		ua: getUA(),
		rt: rt,
	}

/// info | 情報

*path operation 関数*の中で宣言している依存関係は`query_or_cookie_extractor`の1つだけであることに注意してください。

しかし、**FastAPI** は`query_extractor`を最初に解決し、その結果を`query_or_cookie_extractor`を呼び出す時に渡す必要があることを知っています。

///

```mermaid
graph TB

query_extractor(["query_extractor"])
query_or_cookie_extractor(["query_or_cookie_extractor"])

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```