from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel, HttpUrl

app = FastAPI()


class Image(BaseModel):
    url: HttpUrl
    name: str


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None
    tags: set[str] = set()
    images: Union[list[Image], None] = None


@app.put("/items/{item_id}")

     */
    @Test
    public void testIsTarget() throws Exception {
        final NumberConverter converter = new NumberConverter("##0");
        assertThat(converter.isTarget(Integer.class), is(true));
        assertThat(converter.isTarget(Timestamp.class), is(not(true)));
    }

from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class JsonApiResponse(JSONResponse):
    media_type = "application/vnd.api+json"


class Error(BaseModel):
    status: str
    title: str


class JsonApiError(BaseModel):
    errors: typing.List[Error]


@app.get(
    "/a",
    response_class=JsonApiResponse,

@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = UriTypeValidator.class)
public @interface UriType {

    ProtocolType protocolType();

    String message() default "{org.lastaflute.validator.constraints.UriType.message}";

    Class<?>[] groups() default {};

    Class<? extends Payload>[] payload() default {};

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListGetTester<E> extends AbstractListTester<E> {
  public void testGet_valid() {
    // This calls get() on each index and checks the result:
    expectContents(createOrderedArray());
  }

  public void testGet_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().get(-1));
  }

  public void testGet_tooLarge() {

import java.util.List;

public class AbstractNotAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    public abstract void overriddenInSubclassNowhereAnnotated(Object o);

    public abstract void overriddenAndAnnotatedInSubclass(Object o);
  }

  static class SubClass extends SuperClass {

So, having a nice PR title will not only look nice in GitHub, but also in the release notes. 📝

## Add Labels to PRs

from typing_extensions import Annotated, deprecated

from ._compat import PYDANTIC_V2, PYDANTIC_VERSION, Undefined

_Unset: Any = Undefined


class ParamTypes(Enum):
    query = "query"
    header = "header"
    path = "path"
    cookie = "cookie"


class Param(FieldInfo):
    in_: ParamTypes

    def __init__(
        self,
        default: Any = Undefined,
        *,

      assertThat(it.code).isEqualTo(200)
    }
  }

  @ParameterizedTest
  @ArgumentsSource(SampleTestProvider::class)
  fun testParams(mode: String) {
  }
}

class SampleTestProvider : SimpleProvider() {
  override fun arguments() = listOf("A", "B")

 *
 * @author Louis Wasserman
 */
@ElementTypesAreNonnullByDefault
final class LongAddables {
  private static final Supplier<LongAddable> SUPPLIER;

  static {
    Supplier<LongAddable> supplier;
    try {
      // trigger static initialization of the LongAdder class, which may fail
      LongAdder unused = new LongAdder();
      supplier =
          new Supplier<LongAddable>() {