this.type = checkNotNull(type);
    this.comparator = comparator;
    checkState((type == Type.SORTED) == (comparator != null));
  }

  /** Returns an instance which specifies that no ordering is guaranteed. */
  public static <S> ElementOrder<S> unordered() {
    return new ElementOrder<>(Type.UNORDERED, null);
  }

  /**
   * Returns an instance which specifies that ordering is guaranteed to be always be the same across

    this.type = checkNotNull(type);
    this.comparator = comparator;
    checkState((type == Type.SORTED) == (comparator != null));
  }

  /** Returns an instance which specifies that no ordering is guaranteed. */
  public static <S> ElementOrder<S> unordered() {
    return new ElementOrder<>(Type.UNORDERED, null);
  }

  /**
   * Returns an instance which specifies that ordering is guaranteed to be always be the same across

 *
 */
public class MessageDigestUtilTest {
    /**
     *
     */
    @Test
    public void testDigest() {
        final String text = "hoge";
        assertNull(MessageDigestUtil.digest("MD5", null));
        assertEquals("ea703e7aa1efda0064eaa507d9e8ab7e", MessageDigestUtil.digest("MD5", text));
        assertEquals("31f30ddbcb1bf8446576f0e64aa4c88a9f055e3c", MessageDigestUtil.digest("SHA-1", text));

    /**
     * Gets the assembled toolchains.
     *
     * @return The assembled toolchains, never {@code null}.
     */
    PersistedToolchains getEffectiveToolchains();

    /**
     * Return a list of problems, if any.
     *
     * @return a list of problems, never {@code null}.
     */
    List<Problem> getProblems();

  public void testCount_nullAbsent() {
    assertEquals("multiset.count(null) didn't return 0", 0, getMultiset().count(null));
  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_QUERIES)
  public void testCount_null_forbidden() {
    assertThrows(NullPointerException.class, () -> getMultiset().count(null));
  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)

        if ( a.atLeast(b) ) {
            return a;
        }
        return b;
    }


    /**
     * @param min
     *            may be null for open end
     * @param max
     *            may be null for open end
     * @return range of versions
     */
    public static Set<DialectVersion> range ( DialectVersion min, DialectVersion max ) {

  @CheckForNull
  public E lower(E element) {
    int index = headIndex(element, false) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E floor(E element) {
    int index = headIndex(element, true) - 1;
    return (index == -1) ? null : elements.get(index);
  }

  @Override
  @CheckForNull
  public E ceiling(E element) {

esac

# Stops the service
if [ "$STOP_REQUIRED" = "true" ]; then
    echo -n "Stopping fess service..."
    if command -v systemctl >/dev/null; then
        systemctl --no-reload stop fess.service > /dev/null 2>&1 || true

    elif [ -x /etc/init.d/fess ]; then
        if command -v invoke-rc.d >/dev/null; then
            invoke-rc.d fess stop || true
        else
            /etc/init.d/fess stop || true
        fi

  private @Nullable Set<Throwable> seenExceptions = null;
  private int remaining;

  AggregateFutureState(int remainingFutures) {
    this.remaining = remainingFutures;
  }

  final Set<Throwable> getOrInitSeenExceptions() {
    if (seenExceptions == null) {
      seenExceptions = newHashSet();
      addInitialException(seenExceptions);
    }

     *
     * @param lifecycleId The identifier of the lifecycle that could not be located, may be {@code null}.
     */
    public LifecycleNotFoundException(String lifecycleId) {
        super("Unknown lifecycle " + lifecycleId);
        this.lifecycleId = (lifecycleId != null) ? lifecycleId : "";
    }

    /**
     * Gets the identifier of the lifecycle that was not found.
     *