* See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.testing

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
@Retention(AnnotationRetention.RUNTIME)
/**
 * Annotation marking a test as flaky, and requires extra logging and linking against
 * a known github issue.  This does not ignore the failure.
 */

      assertThat(
        connection.inputStream
          .source()
          .buffer()
          .readUtf8(),
      ).contains("Peter the person")
    }
  }

  private fun testRequest(function: (MockServerClient) -> Unit) {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      val request =
        request()
          .withPath("/person")

 * limitations under the License.
 */

package com.google.common.collect;

import static java.util.Arrays.asList;

import com.google.common.base.Function;
import com.google.common.collect.Multiset.Entry;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package logger

import (
	"context"
	"errors"
	"sync"
	"time"
)

// LogOnce provides the function type for logger.LogOnceIf() function
type LogOnce func(ctx context.Context, err error, id string, errKind ...any)

type onceErr struct {
	Err   error
	Count int
}

// Holds a map of recently logged errors.

# `Request` class

You can declare a parameter in a *path operation function* or dependency to be of type `Request` and then you can access the raw request object directly, without any validation, etc.

You can import it directly from `fastapi`:

```python
from fastapi import Request
```

/// tip

import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.Spliterator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

					// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
					// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
					// This changes the SP, thus we have to update the SP used by the imported function.

					// func wasmExit(code int32)
					"runtime.wasmExit": (sp) => {
						sp >>>= 0;

import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.stream.Collector;
import org.jspecify.annotations.Nullable;

/**

    /** Verify all writes flag */
    int FLAGS_VERIFY_ALL_WRITES = 0x0010;
    /** Tree copy flag */
    int FLAGS_TREE_COPY = 0x0020;

    // open function
    /** Open function fail if exists */
    int OPEN_FUNCTION_FAIL_IF_EXISTS = 0x0000;
    /** Open function overwrite if exists */
    int OPEN_FUNCTION_OVERWRITE_IF_EXISTS = 0x0020;

    /** Process ID */
    int PID = (int) (Math.random() * 65536d);

{* ../../docs_src/authentication_error_status_code/tutorial001_an_py39.py hl[9:13] *}

/// tip

Notice that the function returns the exception instance, it doesn't raise it. The raising is done in the rest of the internal code.