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);

You can add middleware to **FastAPI** applications.

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.

        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

    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 {

    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 {

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:

 * 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>
 *

        }
    }

    @Nested
    @DisplayName("Interface Method Contract Tests")
    class InterfaceMethodContractTests {

        @Test
        @DisplayName("Should define getSID method returning SID")
        void shouldDefineMethods() {
            ACE ace = mock(ACE.class);
            SID mockSid = mock(SID.class);
            when(ace.getSID()).thenReturn(mockSid);

public class CallablesTest extends TestCase {

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

    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());
  }

  @J2ktIncompatible

 * 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>
 *