tests, either. This causes it to fail to find AtomicLongMapTest.

    Our workaround is to tell GWT that util.concurrent and all other packages
    have prod supersource, even if they have none. GWT is happy to ignore us
    when we specify a nonexistent path.

    (I hope that this workaround does not cause its own problems in the future.)
-->
<super-source path="super"/>

   * @return an unmodifiable list containing the cause chain starting with {@code throwable}
   * @throws IllegalArgumentException if there is a loop in the causal chain
   */
  public static List<Throwable> getCausalChain(Throwable throwable) {
    checkNotNull(throwable);
    List<Throwable> causes = new ArrayList<>(4);
    causes.add(throwable);

   * @return an unmodifiable list containing the cause chain starting with {@code throwable}
   * @throws IllegalArgumentException if there is a loop in the causal chain
   */
  public static List<Throwable> getCausalChain(Throwable throwable) {
    checkNotNull(throwable);
    List<Throwable> causes = new ArrayList<>(4);
    causes.add(throwable);

	updateCallback.Clauses = config.UpdateClauses

	rowCallback := db.Callback().Row()
	rowCallback.Register("gorm:row", RowQuery)
	rowCallback.Clauses = config.QueryClauses

	rawCallback := db.Callback().Raw()
	rawCallback.Register("gorm:raw", RawExec)
	rawCallback.Clauses = config.QueryClauses

 * Any IO - writing to files or network should be done asynchronously.
 */
@ExperimentalOkHttpApi
abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(

    this.suppressThrows = suppressThrows;
  }

  @Override
  public final void addTearDown(TearDown tearDown) {
    synchronized (stack) {
      stack.addFirst(checkNotNull(tearDown));
    }
  }

  /** Causes teardown to execute. */
  public final void runTearDown() {
    List<Throwable> exceptions = new ArrayList<>();
    List<TearDown> stackCopy;
    synchronized (stack) {
      stackCopy = Lists.newArrayList(stack);

/**
 * Service interface to parse {@link Version} and {@link VersionRange}.
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionParser extends Service {

    /**
     * Parses the specified version string, for example "1.0".
     *
     * @param version the version string to parse, must not be {@code null}
     * @return the parsed version, never {@code null}

        {"name": "baz", "price": "baz"},
    ]


client = TestClient(app)


def test_invalid():
    with pytest.raises(ResponseValidationError):
        client.get("/items/invalid")


def test_invalid_none():
    with pytest.raises(ResponseValidationError):
        client.get("/items/invalidnone")


def test_valid_none_data():
    response = client.get("/items/validnone")

     * @param count the number of misses to record
     * @since 11.0
     */
    void recordMisses(int count);

    /**
     * Records the successful load of a new entry. This should be called when a cache request causes
     * an entry to be loaded, and the loading completes successfully. In contrast to {@link
     * #recordMisses}, this method should only be called by the loading thread.
     *

    client = TestClient(app)
    with pytest.raises(WebSocketDisconnect):
        with client.websocket_connect("/items/foo/ws"):
            pytest.fail(
                "did not raise WebSocketDisconnect on __enter__"
            )  # pragma: no cover


@needs_py310
def test_websocket_invalid_data(app: FastAPI):
    client = TestClient(app)
    with pytest.raises(WebSocketDisconnect):