* second invocation, so implementors have made various choices, including:
 *
 * <ul>
 *   <li>returning the same iterator again
 *   <li>throwing an exception of some kind
 *   <li>or the usual, <i>robust</i> behavior, which all known {@link Collection} implementations
 *       have, of returning a new, independent iterator
 * </ul>
 *

FastAPI will use this return type to:

* **Validate** the returned data.
    * If the data is invalid (e.g. you are missing a field), it means that *your* app code is broken, not returning what it should, and it will return a server error instead of returning incorrect data. This way you and your clients can be certain that they will receive the data and the data shape expected.
* Add a **JSON Schema** for the response, in the OpenAPI *path operation*.

    }

    /**
     * ClassWorld Launcher "enhanced" entry point: returning exitCode and accepts Class World.
     */
    public static int main(String[] args, ClassWorld world) throws IOException {
        return new MavenCling(world).run(args, null, null, null, false);
    }

    /**
     * ClassWorld Launcher "embedded" entry point: returning exitCode and accepts Class World and streams.
     */
    public static int main(

    super.setUp();
    timeLimiter = new FakeTimeLimiter();
  }

  public void testCallWithTimeout_propagatesReturnValue() throws Exception {
    String result =
        timeLimiter.callWithTimeout(Callables.returning(RETURN_VALUE), DELAY_MS, MILLISECONDS);

    assertThat(result).isEqualTo(RETURN_VALUE);
  }

  public void testCallWithTimeout_wrapsCheckedException() throws Exception {

**FastAPI** provides the same `starlette.responses` as `fastapi.responses` just as a convenience for you, the developer. But most of the available responses come directly from Starlette.

///

## Returning a custom `Response` { #returning-a-custom-response }

        mockNotifications.add(fileNotifyInfo1);
        mockNotifications.add(fileNotifyInfo2);
        mockNotifications.add(fileNotifyInfo3);
    }

    /**
     * Test watch() method returning notifications
     */
    @Test
    void testWatch() throws CIFSException {
        // Setup mock behavior
        when(watchHandle.watch()).thenReturn(mockNotifications);

        // Execute

You can also declare the `Response` parameter in dependencies, and set cookies (and headers) in them.

## Return a `Response` directly { #return-a-response-directly }

You can also create cookies when returning a `Response` directly in your code.

To do that, you can create a response as described in [Return a Response Directly](response-directly.md){.internal-link target=_blank}.

Then set Cookies in it, and then return it:

public class CallablesTest extends TestCase {

  @J2ktIncompatible // TODO(b/324550390): Enable
  public void testReturning() throws Exception {
    assertThat(Callables.returning(null).call()).isNull();

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertSame(value, callable.call());
    // Expect the same value on subsequent calls
    assertSame(value, callable.call());
  }

    assertFalse(task.isDone());
    task.run();
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());
    assertEquals(2, getDone(task).intValue());
  }

  public void testCancelled() throws Exception {
    TrustedListenableFutureTask<Integer> task = TrustedListenableFutureTask.create(returning(2));
    assertFalse(task.isDone());
    task.cancel(false);

    class DecodingTests {

        @Test
        @DisplayName("Should decode value correctly")
        void testDecode() throws NdrException {
            // Given: NdrShort and mock returning specific value
            int decodedValue = 200;
            NdrShort ndrShort = new NdrShort(0);
            when(mockBuffer.dec_ndr_short()).thenReturn(decodedValue);

            // When: Decoding the value