// Enable it only for the main source set by default, as incremental Groovy
        // joint-compilation doesn't work with the Error Prone annotation processor
        extension.enabled.convention(this.name == "main")

        project.dependencies.addProvider(
            annotationProcessorConfigurationName,

                   prod code. It's disabled automatically for "test code"
                   (which is good: our tests have intentional violations), but
                   Error Prone doesn't know it's building test code unless we
                   pass -XepCompilingTestOnlyCode, and that argument needs to
                   be passed as part of the same <arg> as -Xplugin:ErrorProne,

                   prod code. It's disabled automatically for "test code"
                   (which is good: our tests have intentional violations), but
                   Error Prone doesn't know it's building test code unless we
                   pass -XepCompilingTestOnlyCode, and that argument needs to
                   be passed as part of the same <arg> as -Xplugin:ErrorProne,

		t.Fatal("expected pod to be in cache")
	}
}

// for tests that call `runtime.GC()` - we have no control over when the GC is actually scheduled,
// and it is flake-prone to check for closure after calling it, this retries for a bit to make
// sure the netns is closed eventually.
func assertNSClosed(t *testing.T, closed *atomic.Bool) {
	for i := 0; i < 5; i++ {
		if closed.Load() {

        result.set(i, getAt(currentStripe));
        previousStripe = currentStripe;
      }
    }
    /*
     * Note that the returned Iterable holds references to the returned stripes, to avoid
     * error-prone code like:
     *
     * Striped<Lock> stripedLock = Striped.lazyWeakXXX(...)'
     * Iterable<Lock> locks = stripedLock.bulkGet(keys);
     * for (Lock lock : locks) {
     *   lock.lock();
     * }

  }

  /**
   * This test attempts to cause a future to wait for longer than it was requested to from a timed
   * get() call. As measurements of time are prone to flakiness, it tries to assert based on ranges
   * derived from observing how much time actually passed for various operations.
   */
  @SuppressWarnings("ThreadPriorityCheck")
  @AndroidIncompatible // Thread.suspend

# Asynchrone Tests

Sie haben bereits gesehen, wie Sie Ihre **FastAPI**-Anwendungen mit dem bereitgestellten `TestClient` testen. Bisher haben Sie nur gesehen, wie man synchrone Tests schreibt, ohne `async`hrone Funktionen zu verwenden.

Der auf die `yield`-Anweisung folgende Code wird ausgeführt, nachdem die Response gesendet wurde:

```Python hl_lines="5-6"
{!../../docs_src/dependencies/tutorial007.py!}
```

/// tip | "Tipp"

Sie können `async`hrone oder reguläre Funktionen verwenden.

**FastAPI** wird bei jeder das Richtige tun, so wie auch bei normalen Abhängigkeiten.

///

## Eine Abhängigkeit mit `yield` und `try`.

* Sie können Metadaten aus der hochgeladenen Datei auslesen.
* Es hat eine <abbr title="dateiartig"><a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a></abbr> `async`hrone Schnittstelle.

        layers and happens to work before TF 2.4. These will explicitly be
        unsupported now. Converting these ops to Functional API op layers was
        unreliable before TF 2.4, and prone to erroring incomprehensibly or
        being silently buggy.
    *   Code that directly asserts on a Keras symbolic value in cases where ops
        like `tf.rank` used to return a static or symbolic value depending on if