El código de salida, el cierre automático de la `Session` en:

{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}

...se ejecutaría después de que la response termine de enviar los datos lentos:

{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}

Pero como `generate_stream()` no usa la sesión de base de datos, no es realmente necesario mantener la sesión abierta mientras se envía la response.

        // Act & Assert
        assertEquals(2222, transport.getResponseTimeout(req));
    }

    @Test
    @DisplayName("Basic getters: address, hostName, inflight, sessions")
    void basicGetters() {
        assertEquals(address, transport.getRemoteAddress());
        assertNull(transport.getRemoteHostName(), "tconHostName starts null");

	if err := DB.AutoMigrate(&MigrateInt{}); err != nil {
		t.Fatalf("Failed to auto migrate: error: %v", err)
	}

	// make new session to set custom logger tracer
	session := DB.Session(&gorm.Session{Logger: tracer})

	// The second AutoMigrate to catch an error
	if err := session.AutoMigrate(&MigrateInt{}); err != nil {
		t.Fatalf("Failed to auto migrate: error: %v", err)
	}
}

        // Session starts with usage count > 0, so acquire/release cycles maintain usage
        assertTrue(session.isInUse(), "Session should be in use initially");

        // Test acquire/release cycles (session remains in use due to initial transport acquire)
        for (int i = 0; i < 3; i++) {
            session.acquire();
            assertTrue(session.isInUse(), "Session should be in use after acquire " + i);

            session.release();

def get_session():
    with Session(engine) as session:
        yield session


app = FastAPI()


@app.on_event("startup")
def on_startup():
    create_db_and_tables()


@app.post("/heroes/")
def create_hero(hero: Hero, session: Session = Depends(get_session)) -> Hero:
    session.add(hero)
    session.commit()
    session.refresh(hero)
    return hero


@app.get("/heroes/")

        .build()
    val session = session(heldCertificate.certificatePem())
    assertThat(verifier.verify("foo.com", session)).isFalse()
    assertThat(verifier.verify("bar.com", session)).isFalse()
    assertThat(verifier.verify("k.com", session)).isTrue()
    assertThat(verifier.verify("K.com", session)).isTrue()
    assertThat(verifier.verify("\u2121.com", session)).isFalse()

        List<Toolchain> toolchains = toolchainManager.getToolchains(session, "rare", null);

        assertEquals(1, toolchains.size());
    }

    @Test
    void testModelsAndFactory() {
        MavenSession session = mock(MavenSession.class);
        Session sessionv4 = mock(Session.class);
        when(session.getSession()).thenReturn(sessionv4);
        when(sessionv4.getToolchains())
                .thenReturn(List.of(

        byte[] key = new byte[] { 10, 20 };
        when(session.getSessionKey()).thenReturn(key, new byte[0], null);

        assertArrayEquals(key, session.getSessionKey());
        assertArrayEquals(new byte[0], session.getSessionKey());
        assertNull(session.getSessionKey());
        verify(session, times(3)).getSessionKey();
    }

    // Error propagation: getSessionKey throws CIFSException

    hero_db.sqlmodel_update(hero_data)
    session.add(hero_db)
    session.commit()
    session.refresh(hero_db)
    return hero_db


@app.delete("/heroes/{hero_id}")
def delete_hero(hero_id: int, session: SessionDep):
    hero = session.get(Hero, hero_id)
    if not hero:
        raise HTTPException(status_code=404, detail="Hero not found")
    session.delete(hero)
    session.commit()

     * Creates a new ProjectBuilderRequest with the specified session and source.
     *
     * @param session the Maven session
     * @param source the source of the project to build
     * @return a new ProjectBuilderRequest
     * @throws NullPointerException if session or source is null
     */
    @Nonnull
    static ProjectBuilderRequest build(@Nonnull Session session, @Nonnull Source source) {
        return builder()