transport.setState(3); // Connected
            assertTrue(transport.connect(1000));
        }

        @Test
        @DisplayName("connect should throw TransportException on connection failure")
        void shouldThrowOnConnectionFailure() {
            transport.setState(0); // Not connected
            transport.setConnectFails(true);

        throw new NullPointerException("at index " + i);
      }
      list.add(element);
    }
    equalityGroups.add(list);
    return this;
  }

  /** Run tests on equals method, throwing a failure on an invalid test */
  @CanIgnoreReturnValue
  public EqualsTester testEquals() {
    RelationshipTester<Object> delegate =
        new RelationshipTester<>(

        assertEquals("Invalid token", ex.getMessage());

        // Ensure mechContext was not engaged due to early failure
        verify(this.mechContext, never()).initSecContext(any(), anyInt(), anyInt());
    }

    @Test
    @DisplayName("initSecContext with null buffer and non-zero len throws NPE")

    List<?> exp = copyToList(expected);
    List<?> act = copyToList(actual);
    String actString = act.toString();

    // Of course we could take pains to give the complete description of the
    // problem on any failure.

    // Yeah it's n^2.
    for (Object object : exp) {
      if (!act.remove(object)) {
        fail(
            "did not contain expected element "
                + object
                + ", "

# Application Exception
# ---------------------
# /- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# five framework-embedded messages (don't change key names)
# - - - - - - - - - -/
errors.login.failure = Anmeldung fehlgeschlagen.
errors.app.illegal.transition = Ungültiger Übergang. Bitte versuchen Sie es erneut.

 * hint, so this technique may fail at the whim of the JDK implementation, for example if a user
 * specified the JVM flag {@code -XX:+DisableExplicitGC}. But in practice, it works very well for
 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *

     */
    long getDfsTtl();

    /**
     *
     * Property {@code jcifs.smb.client.dfs.strictView} (boolean, default false)
     *
     * @return whether a authentication failure during DFS resolving will throw an exception
     */
    boolean isDfsStrictView();

    /**
     *
     * Property {@code jcifs.smb.client.dfs.disabled} (boolean, default false)
     *

   *     future
   * @param executor Executor to run the function in.
   * @return A future that holds result of the function (if the input succeeded) or the original
   *     input's failure (if not)
   */
  public final <T extends @Nullable Object> FluentFuture<T> transformAsync(
      AsyncFunction<? super V, T> function, Executor executor) {

# Application Exception
# ---------------------
# /- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
# five framework-embedded messages (don't change key names)
# - - - - - - - - - -/
errors.login.failure = लॉगिन विफल रहा।
errors.app.illegal.transition = अवैध परिवर्तन। कृपया पुनः प्रयास करें।
errors.app.db.already.deleted = इसे किसी अन्य प्रक्रिया द्वारा हटाया जा सकता है। कृपया पुनः प्रयास करें।

 *     try (ResponseBody responseBody = response.body()) {
 *     ... // Use the response.
 *     }
 *   }
 *
 *   public void onFailure(Call call, IOException e) {
 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *
 * These examples will not work if you're consuming the response body on another thread. In such
 * cases the consuming thread must call [close] when it has finished reading the response