from fastapi import FastAPI
from fastapi.responses import JSONResponse
from pydantic import BaseModel


class Item(BaseModel):
    id: str
    value: str


class Message(BaseModel):
    message: str


app = FastAPI()


@app.get("/items/{item_id}", response_model=Item, responses={404: {"model": Message}})
async def read_item(item_id: str):
    if item_id == "foo":

import org.codelibs.core.beans.impl.BeanDescImpl;
import org.codelibs.core.misc.DisposableUtil;

/**
 * This class generates {@link BeanDesc}.
 * <p>
 * It returns a {@link BeanDesc} that handles the metadata of the specified JavaBeans.
 * </p>
 *
 * <pre>
 * BeanDesc beanDesc = BeanDescFactory.getBeanDesc(Foo.class);
 * </pre>
 * <p>
 * {@link BeanDesc} is cached. To clear the cache, call {@link DisposableUtil#dispose()}.
 * </p>

    }
    assertThrows(IndexOutOfBoundsException.class, () -> refArray.get(array.length));
  }

  public void testNewReferenceArray_withNullArray() throws Exception {
    assertThrows(NullPointerException.class, () -> Atomics.newReferenceArray(null));
  }

  public void testNullPointers() {
    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicConstructors(Atomics.class); // there aren't any

import org.jspecify.annotations.Nullable;

/**
 * A class to represent the set of edges connecting an (implicit) origin node to a target node.
 *
 * <p>The {@link #nodeToOutEdge} map means this class only works on networks without parallel edges.
 * See {@link MultiEdgesConnecting} for a class that works with parallel edges.
 *
 * @author James Sexton
 * @param <E> Edge parameter type
 */
final class EdgesConnecting<E> extends AbstractSet<E> {

import jcifs.internal.smb2.info.Smb2QueryInfoRequest;
import jcifs.internal.smb2.io.Smb2ReadRequest;

/**
 * Unit tests for ChannelLoadBalancer
 */
@ExtendWith(MockitoExtension.class)
class ChannelLoadBalancerTest {

    @Mock
    private ChannelManager mockChannelManager;

    @Mock
    private SmbTransport mockTransport1;

    @Mock
    private SmbTransport mockTransport2;

   * }
   * if (failure != null) {
   *   throwIfInstanceOf(failure, BarException.class);
   *   throwIfUnchecked(failure);
   *   throw new AssertionError(failure);
   * }
   * </pre>
   *
   * @since 20.0
   */
  @GwtIncompatible // Class.cast, Class.isInstance
  public static <X extends Throwable> void throwIfInstanceOf(
      Throwable throwable, Class<X> declaredType) throws X {
    checkNotNull(throwable);

Hay un mini <a href="https://sqlmodel.tiangolo.com/tutorial/fastapi/" class="external-link" target="_blank">tutorial sobre el uso de SQLModel con FastAPI</a>. ✨

import jcifs.internal.util.SMBUtil;

@DisplayName("Smb2Lock Test")
class Smb2LockTest {

    private Smb2Lock lock;
    private byte[] buffer;

    @BeforeEach
    void setUp() {
        buffer = new byte[128];
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test
        @DisplayName("Should create lock with valid parameters")

import java.util.Map;
import org.jspecify.annotations.Nullable;

/** A {@code RegularImmutableTable} optimized for dense data. */
@GwtCompatible
@Immutable(containerOf = {"R", "C", "V"})
final class DenseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
  private final ImmutableMap<R, Integer> rowKeyToIndex;
  private final ImmutableMap<C, Integer> columnKeyToIndex;

        mSession.setSession(iSession);

        SessionScope sessionScope = getContainer().lookup(SessionScope.class);
        sessionScope.enter();
        sessionScope.seed(MavenSession.class, mSession);
        sessionScope.seed(Session.class, iSession);
        sessionScope.seed(InternalMavenSession.class, InternalMavenSession.from(iSession));
    }

    protected MavenProject createStubMavenProject() {