// Then - verify command is set correctly using reflection
        Field commandField = ServerMessageBlock2.class.getDeclaredField("command");
        commandField.setAccessible(true);
        int command = (int) commandField.get(req);

        assertEquals(SMB2_TREE_DISCONNECT, command);
    }

    @Test
    @DisplayName("Should create proper response object")
    void testCreateResponse() {

        when(mockFile2.length()).thenReturn(0L);
        when(mockFile2.lastModified()).thenReturn(System.currentTimeMillis() - 1800000);
        when(mockFile2.isDirectory()).thenReturn(true);
        when(mockFile2.getAttributes()).thenReturn(0x10); // FILE_ATTRIBUTE_DIRECTORY
        when(mockFile2.createTime()).thenReturn(System.currentTimeMillis() - 7200000);

```

con un JSON body que contiene algo como:

```JSON
{
    "description": "Payment celebration",
    "paid": true
}
```

y esperaría un response de esa *API externa* con un JSON body como:

```JSON
{
    "ok": true
}
```

/// tip | Consejo

  }

  private static final class IntegerDomain extends DiscreteDomain<Integer> implements Serializable {
    private static final IntegerDomain INSTANCE = new IntegerDomain();

    IntegerDomain() {
      super(true);
    }

    @Override
    public @Nullable Integer next(Integer value) {
      int i = value;
      return (i == Integer.MAX_VALUE) ? null : i + 1;
    }

    @Override

          stale-issue-label: to-triage
          stale-issue-message: ""
          days-before-issue-close: -1

          only-pr-labels: 'from:contributor'
          exempt-all-pr-milestones: true
          days-before-pr-stale: 14
          stale-pr-label: to-triage
          stale-pr-message: ""

   * <p>For example:
   *
   * {@snippet :
   * PLAIN_TEXT_UTF_8.is(PLAIN_TEXT_UTF_8) // true
   * PLAIN_TEXT_UTF_8.is(HTML_UTF_8) // false
   * PLAIN_TEXT_UTF_8.is(ANY_TYPE) // true
   * PLAIN_TEXT_UTF_8.is(ANY_TEXT_TYPE) // true
   * PLAIN_TEXT_UTF_8.is(ANY_IMAGE_TYPE) // false
   * PLAIN_TEXT_UTF_8.is(ANY_TEXT_TYPE.withCharset(UTF_8)) // true
   * PLAIN_TEXT_UTF_8.withoutParameters().is(ANY_TEXT_TYPE.withCharset(UTF_8)) // false

 * </pre>
 *
 * <p>This tests:
 *
 * <ul>
 *   <li>comparing each object against itself returns true
 *   <li>comparing each object against null returns false
 *   <li>comparing each object against an instance of an incompatible class returns false
 *   <li>comparing each pair of objects within the same equality group returns true
 *   <li>comparing each pair of objects from different equality groups returns false

     * @throws IOException if reset fails
     */
    public abstract void reset() throws IOException;

    /**
     * Check if connection can send data (has send credits and is established)
     *
     * @return true if can send, false otherwise
     */
    public boolean canSend() {
        return sendCredits.get() > 0 && state == RdmaConnectionState.ESTABLISHED;
    }

    /**
     * Consume a send credit
     */

            }
        }
    }

    @Nested
    @DisplayName("Connection lifecycle tests")
    class ConnectionLifecycleTests {

        @Test
        @DisplayName("connect should return true if already connected")
        void shouldReturnTrueIfAlreadyConnected() throws TransportException {
            transport.setState(3); // Connected
            assertTrue(transport.connect(1000));
        }

        public <CREDENTIAL extends LoginCredential> void resolve(final Class<CREDENTIAL> credentialType,
                final Function<CREDENTIAL, OptionalEntity<FessUser>> oneArgLambda) {
            this.resolveCalled = true;
            this.lastCredentialType = credentialType;
            this.lastFunction = oneArgLambda;
        }

        public boolean isResolveCalled() {
            return resolveCalled;
        }