participant operation as Path Operation
participant tasks as Background tasks

    Note over client,operation: Can raise exceptions, including HTTPException
    client ->> dep: Start request
    Note over dep: Run code up to yield
    opt raise Exception
        dep -->> handler: Raise Exception
        handler -->> client: HTTP error response
    end
    dep ->> operation: Run dependency, e.g. DB session
    opt raise

import java.util.function.BiFunction;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * An implementation of {@code RangeMap} based on a {@code TreeMap}, supporting all optional
 * operations.
 *
 * <p>Like all {@code RangeMap} implementations, this supports neither null keys nor null values.
 *
 * @author Louis Wasserman
 * @since 14.0
 */

-->

## Introduction {#intro}

Go's emphasis on backwards compatibility is one of its key strengths.
There are, however, times when we cannot maintain complete compatibility.
If code depends on buggy (including insecure) behavior,
then fixing the bug will break that code.
New features can also have similar impacts:
enabling the HTTP/2 use by the HTTP client broke programs
connecting to servers with buggy HTTP/2 implementations.

    /**
     * Tricky case: flat directory structure, but child directory != artifactId.
     * Model interpolation does not give same result when calculated from build or from repo...
     * This is why MNG-5000 fix in code is marked as bad practice (uses file names)
     * @throws IOException Model read problem
     */
    @Test
    void testFlatTrickyUrls() throws IOException {

	if err != nil {
		return nil, "", "", "", err
	}
	return clientset, "", namespace, selector.String(), nil
}

// this is used for testing. it should not be changed in regular code.
var getFirstPodFunc func(client corev1client.PodsGetter, namespace string, selector string, timeout time.Duration,
	sortBy func([]*corev1.Pod) sort.Interface) (*corev1.Pod, int, error)

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package zip

import (
	"compress/flate"
	"errors"
	"io"
	"sync"
)

// A Compressor returns a new compressing writer, writing to w.
// The WriteCloser's Close method must be used to flush pending data to w.
// The Compressor itself must be safe to invoke from multiple goroutines

        if (newPath != null) {
            return newPath;
        }
        return path;
    }

    /**
     * Returns aligned path or {@code null} if no need for change.
     */
    private String mayAlignToBaseDirectoryOrNull(String path, Path basedir) {
        String newPath = pathTranslator.alignToBaseDirectory(path, basedir);

///

```Python hl_lines="7"
{!> ../../docs_src/dependencies/tutorial011.py!}
```

////

In diesem Fall wird **FastAPI** `__init__` nie berühren oder sich darum kümmern, wir werden es direkt in unserem Code verwenden.

## Eine Instanz erstellen

Wir könnten eine Instanz dieser Klasse erstellen mit:

//// tab | Python 3.9+

```Python hl_lines="18"
{!> ../../docs_src/dependencies/tutorial011_an_py39.py!}
```

    private val response =
      Response.Builder()
        .request(Request("https://example.com/".toHttpUrl()))
        .protocol(Protocol.HTTP_1_1)
        .message("OK")
        .code(200)
        .body(
          object : ResponseBody() {
            override fun contentType() = null

            override fun contentLength() = -1L

            override fun source() =

    name: String,
    vararg values: String,
  ) = apply {
    assertThat(request.headers(name)).containsExactly(*values)
  }

  fun assertCode(expectedCode: Int) =
    apply {
      assertThat(response!!.code).isEqualTo(expectedCode)
    }

  fun assertSuccessful() =
    apply {
      assertThat(failure).isNull()
      assertThat(response!!.isSuccessful).isTrue()
    }

  fun assertNotSuccessful() =
    apply {