}

  /**
   * This test attempts to cause a future to wait for longer than it was requested to from a timed
   * get() call. As measurements of time are prone to flakiness, it tries to assert based on ranges
   * derived from observing how much time actually passed for various operations.
   */
  @SuppressWarnings("ThreadPriorityCheck")
  @AndroidIncompatible // Thread.suspend

     * @param flags Flags that control the behavior of the operation. When all
     * name associated with SIDs will be required, the SID_FLAG_RESOLVE_SIDS
     * flag should be used which causes all group member SIDs to be resolved
     * together in a single more efficient operation.
     */
    static Map getLocalGroupsMap(final String authorityServerName, final NtlmPasswordAuthentication auth, final int flags)

this isn't always possible or practical. In such cases, you should use the
`@SuppressWarnings` annotations to silence the compiler warning, trying to keep
the scope of the suppression as small as possible. Where a piece of code
requires a lot of suppressions, it may be better to apply a single suppression
at a higher level e.g. at the method or even class level. Use your judgement.

        updateConfigListenerMap.put("KeyMatch", () -> Integer.toString(ComponentUtil.getKeyMatchHelper().load()));
    }

    /**
     * Parses project properties from the given path.
     *
     * @param propPath The path to the project properties file.
     * @throws FessSystemException if the properties file cannot be parsed.
     */

because the chimneys were shaped like ears and the roof was
thatched with fur.  It was so large a house, that she did not
like to go nearer till she had nibbled some more of the lefthand
bit of mushroom, and raised herself to about two feet high:  even
then she walked up towards it rather timidly, saying to herself
`Suppose it should be raving mad after all!  I almost wish I'd
gone to see the Hatter instead!'

    assertEquals(a, b);
  }

  @SuppressWarnings("TestExceptionChecker") // see comment below
  public <T> void testVariableTypeTokenNotAllowed() {
    /*
     * We'd use assertThrows here, but that causes no exception to be thrown under Java 8,
     * presumably because the ThrowingRunnable lambda triggers some kind of bug in Java 8's
     * reflection implementation.
     */
    try {
      new TypeToken<T>() {};

   * {@code setFuture} after any cancellation will propagate cancellation to the supplied {@code
   * Future}.
   *
   * <p>Note that, even if the supplied future is cancelled and it causes this future to complete,
   * it will never trigger interruption behavior. In particular, it will not cause this future to
   * invoke the {@link #interruptTask} method, and the {@link #wasInterrupted} method will not

because the chimneys were shaped like ears and the roof was
thatched with fur.  It was so large a house, that she did not
like to go nearer till she had nibbled some more of the lefthand
bit of mushroom, and raised herself to about two feet high:  even
then she walked up towards it rather timidly, saying to herself
`Suppose it should be raving mad after all!  I almost wish I'd
gone to see the Hatter instead!'

      public void handlePotentialDeadlock(PotentialDeadlockException e) {
        logger.get().log(Level.SEVERE, "Detected potential deadlock", e);
      }
    },

    /**
     * Disables cycle detection. This option causes the factory to return unmodified lock
     * implementations provided by the JDK, and is provided to allow applications to easily
     * parameterize when cycle detection is enabled.
     *

Aber wenn Sie in diesem Fall die acht Ex-Kassierer/Köche/jetzt Reinigungskräfte mitbringen würden und jeder von ihnen (plus Sie) würde einen Bereich des Hauses reinigen, könnten Sie die ganze Arbeit **parallel** erledigen, und würden mit dieser zusätzlichen Hilfe viel schneller fertig werden.