/**
   * How many concurrent calls should be possible to make at any time.
   * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
   * Connections will still be closed if they idle beyond the keep-alive but will be replaced.
   */
  @JvmField val minimumConcurrentCalls: Int = 0,
  /** How long to wait to retry pre-emptive connection attempts that fail. */
  @JvmField val backoffDelayMillis: Long = 60 * 1000,

    SettableFuture<String> orig = SettableFuture.create();
    SettableFuture<String> prev = orig;
    for (int i = 0; i < 100000; i++) {
      SettableFuture<String> curr = SettableFuture.create();
      prev.setFuture(curr);
      prev = curr;
    }
    // prev represents the 'innermost' future
    prev.set("done");
    assertTrue(orig.isDone());
  }

 * <tr><td ><pre>
 * new SmbNamedPipe( "smb1://server/IPC$/PIPE/foo",
 *         SmbNamedPipe.PIPE_TYPE_RDWR |
 *         SmbNamedPipe.PIPE_TYPE_CALL );
 * </pre></td><td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td></tr>
 * <tr><td ><pre>
 * new SmbNamedPipe( "smb1://server/IPC$/foo",

import org.hamcrest.Matcher;

/**
 * @author koichik
 */
public abstract class TestUtil {

    /**
     * 実際の値が期待する{@literal clazz}と等しいかを検証する{@link Matcher}を返します。
     *
     * <pre>assertThat(clazz, is(Xxx.class));</pre>
     * <p>
     * と書くと{@link CoreMatchers#is(Class)}が適用されて{@literal clazz}が {@literal Xxx}
     * のインスタンスかを検証されてしまうのでこれが必要。
     *
     * @param clazz
     *            期待するクラス

    @Override
    public String toString() {
        StringBuilder ret = new StringBuilder("SecurityDescriptor:\n");
        if (this.aces != null) {
            for (final ACE element : this.aces) {
                ret.append(element.toString()).append("\n");
            }
        } else {
            ret.append("NULL");
        }
        return ret.toString();
    }

 * </tr>
 * <tr>
 * <td >
 *
 * <pre>
 * new SmbNamedPipe("smb://server/IPC$/PIPE/foo", SmbNamedPipe.PIPE_TYPE_RDWR | SmbNamedPipe.PIPE_TYPE_CALL, context);
 * </pre>
 *
 * </td>
 * <td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td>
 * </tr>
 * <tr>
 * <td >
 *
 * <pre>

 * type exist, the one with the highest priority will be selected for injection.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Priority(100)
 * public class PreferredImplementation implements Service {
 *     // Implementation
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target({TYPE, METHOD})
@Retention(RUNTIME)
@Documented
public @interface Priority {
    /**

   * prev}. {@code ENDPOINT} represents either the first or last entry in the entire map (as
   * appropriate).
   */
  private void setSucceeds(int prev, int next) {
    if (prev == ENDPOINT) {
      firstInInsertionOrder = next;
    } else {
      nextInInsertionOrder[prev] = next;
    }
    if (next == ENDPOINT) {
      lastInInsertionOrder = prev;
    } else {

 *
 * <pre>
 * public class PackageSanityTests extends AbstractPackageSanityTests {}
 * </pre>
 *
 * <p>Note that only top-level classes with either a non-private constructor or a non-private static
 * factory method to construct instances can have their instance methods checked. For example:
 *
 * <pre>
 * public class Address {
 *   private final String city;

        final SuggestCreator creator = ComponentUtil.getComponent(SuggestCreator.class);
        final LocalDateTime startTime = LocalDateTime.now();
        int ret = creator.create();
        if (ret == 0) {
            ret = creator.purge(startTime);
        }
        return ret;
    }

    private int create() {
        if (!ComponentUtil.getFessConfig().isSuggestDocuments() && !ComponentUtil.getFessConfig().isSuggestSearchLog()) {