lc := Lifecycle{
		Rules: []Rule{
			{
				ID:     "rule-1",
				Status: "Enabled",
				Filter: Filter{
					Prefix: Prefix{
						set:    true,
						string: "abcd/",
					},
				},
				Transition: Transition{
					Days:         TransitionDays(3),
					StorageClass: "TIER-1",
				},
			},
			{
				ID:     "rule-2",
				Status: "Enabled",

    String msg = "Alphanumeric characters are always 'safe' and should not be explicitly specified";
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> new PercentEscaper("-+#abc.!", false));
    assertThat(expected).hasMessageThat().isEqualTo(msg);
  }

  public void testBadArguments_plusforspace() {
    // space can be a safe char if plusForSpace is false

import types
import typing
import warnings
from collections import deque
from collections.abc import Mapping, Sequence
from dataclasses import is_dataclass
from typing import (
    Annotated,
    Any,
    TypeGuard,
    TypeVar,
    Union,
    get_args,
    get_origin,
)

from fastapi.types import UnionType
from pydantic import BaseModel
from pydantic.version import VERSION as PYDANTIC_VERSION

  private static final ImmutableSet<String> VALID_NAME =
      ImmutableSet.of(
          // keep-sorted start
          "123.cn",
          "8server.shop",
          "a" + DELTA + "b.com",
          "abc.a23",
          "biz.com.ua",
          "f--1.com",
          "f--o",
          "f-_-o.cOM",
          "f11-1.com",
          "fOo",
          "f_a",
          "foo.com",
          "foo.net.us\uFF61ocm",

        SMBUtil.writeInt4(1, buffer, notifyOffset + 4);
        SMBUtil.writeInt4(6, buffer, notifyOffset + 8); // 6 bytes filename
        System.arraycopy("abc".getBytes("UnicodeLittleUnmarked"), 0, buffer, notifyOffset + 12, 6);

        // Second notification starts at aligned offset
        notifyOffset = 108; // 80 + 28
        SMBUtil.writeInt4(0, buffer, notifyOffset);

import inspect
import sys
from collections.abc import Callable
from dataclasses import dataclass, field
from functools import cached_property, partial
from typing import Any, Literal

from fastapi._compat import ModelField
from fastapi.security.base import SecurityBase
from fastapi.types import DependencyCacheKey

if sys.version_info >= (3, 13):  # pragma: no cover
    from inspect import iscoroutinefunction
else:  # pragma: no cover

  public void testReadEmptyString() throws IOException {
    assertReadsCorrectly("");
  }

  public void testReadsStringsCorrectly() throws IOException {
    assertReadsCorrectly("abc");
    assertReadsCorrectly("abcde");
    assertReadsCorrectly("abcdefghijkl");
    assertReadsCorrectly(
        ""
            + "abcdefghijklmnopqrstuvwxyz\n"
            + "ABCDEFGHIJKLMNOPQRSTUVWXYZ\r"

    //     smaller version of the same problem.
    //     Say we are rotating abcdefgh by 5. We start with abcde|fgh. The smaller block is [fgh]:
    //     [abc]de|[fgh] -> [fgh]de|[abc]. Now [fgh] is in the right place, but we need to swap [de]
    //     with [abc]: fgh[de]|a[bc] -> fgh[bc]|a[de]. Now we need to swap [a] with [bc]:
    //     fgh[b]c|[a]de -> fgh[a]c|[b]de. Finally we need to swap [c] with [b]:

from collections.abc import Mapping, Sequence
from typing import Annotated, Any, TypedDict

from annotated_doc import Doc
from pydantic import BaseModel, create_model
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.exceptions import WebSocketException as StarletteWebSocketException


class EndpointContext(TypedDict, total=False):
    function: str
    path: str
    file: str
    line: int

  }

  @SuppressWarnings("unchecked") // functor classes have no type parameters
  public void testGet_functors() {
    assertEquals(0, ArbitraryInstances.get(Comparator.class).compare("abc", 123));
    assertTrue(ArbitraryInstances.get(Predicate.class).apply("abc"));
    assertTrue(ArbitraryInstances.get(Equivalence.class).equivalent(1, 1));
    assertFalse(ArbitraryInstances.get(Equivalence.class).equivalent(1, 2));
  }