try {
            ByteArrayOutputStream errContent = new ByteArrayOutputStream();
            System.setErr(new PrintStream(errContent));

            String[] args = { "--help" };
            // Note: main calls System.exit, so we can't test it directly
            // Instead, we test the parsing logic separately

            System.setErr(originalErr);
        } catch (Exception e) {
            System.setErr(originalErr);
        }

# Dependencies with yield { #dependencies-with-yield }

FastAPI supports dependencies that do some <abbr title='sometimes also called "exit code", "cleanup code", "teardown code", "closing code", "context manager exit code", etc.'>extra steps after finishing</abbr>.

To do this, use `yield` instead of `return`, and write the extra steps (code) after.

/// tip

Make sure to use `yield` one single time per dependency.

///

/// note | Technical Details

            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in
               * case we ever switch to JUnit 4:
               */
              fail();

		defer ticker.Stop()
		var exit bool
		for !exit {
			select {
			case <-ticker.C:
			case <-ctx.Done():
				exit = true
			}
			metaMu.Lock()
			meta := *mc.meta
			meta, err = o.updateMetacacheListing(meta, rpc)
			if err == nil && time.Since(meta.lastHandout) > metacacheMaxClientWait {
				cancel()
				exit = true
				meta.status = scanStateError

     */
    public static void main(final String[] args) throws Exception {
        if (args.length < 1) {
            logger.error("usage: TestLocking [-t <numThreads>] [-i <numIter>] [-d <delay>] url");
            System.exit(1);
        }

        final TestLocking t = new TestLocking();
        t.ltime = System.currentTimeMillis();

        for (int ai = 0; ai < args.length; ai++) {
            if (args[ai].equals("-t")) {

            Thread.interrupted();
            if (interruptingThread.isAlive()) {
              // This will be hidden by test-output redirection:
              logger.severe("InterruptenatorTask did not exit; future tests may be affected");
              /*
               * This won't do any good under JUnit 3, but I'll leave it around in
               * case we ever switch to JUnit 4:
               */
              fail();

        // Cannot directly test main as it calls System.exit
        // Test argument parsing instead
        SuggestCreator.Options options = new SuggestCreator.Options();
        assertNotNull(options);
    }

    // Test main method with valid arguments
    public void test_main_validArguments() {
        // Cannot directly test main as it calls System.exit
        // Test options parsing instead

          coordinatorWakeUpAt = now + minDelayNanos
          try {
            backend.coordinatorWait(this@TaskRunner, minDelayNanos)
          } catch (_: InterruptedException) {
            // Will cause all tasks to exit unless more are scheduled!
            cancelAll()
          } finally {
            coordinatorWaiting = false
          }
        }
      }
    }
  }

* It can do something to that **response** or run any needed code.
* Then it returns the **response**.

/// note | Technical Details

If you have dependencies with `yield`, the exit code will run *after* the middleware.

If there were any background tasks (covered in the [Background Tasks](background-tasks.md){.internal-link target=_blank} section, you will see it later), they will run *after* all the middleware.

        return connection.socket()
      }
    }

    return null
  }

  private fun timeoutExit(cause: IOException?): IOException? {
    if (timeoutEarlyExit) return cause
    if (!timeout.exit()) return cause

    val e = InterruptedIOException("timeout")
    if (cause != null) e.initCause(cause)
    return e
  }

  /**