void testClosePoolMultipleTimes() throws CIFSException {
            // Given
            when(transportPool.close()).thenReturn(false);

            // When
            boolean result1 = transportPool.close();
            boolean result2 = transportPool.close();

            // Then
            assertFalse(result1);
            assertFalse(result2);
            verify(transportPool, times(2)).close();
        }

      name = method.getName();
      parameterTypes = asList(method.getParameterTypes());
      typeSignature = new TypeSignature(method.getTypeParameters());
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof MethodSignature) {
        MethodSignature other = (MethodSignature) obj;
        return name.equals(other.name)

     * @throws CIFSException if the determination cannot be made
     */
    boolean isWorkgroup() throws CIFSException;

    /**
     * Determines whether this resource represents the root of the SMB hierarchy.
     *
     * @return whether this is a root resource
     */
    boolean isRoot();

     * @return true if comment tags are ignored, false otherwise.
     */
    public boolean isIgnoreCommentTag() {
        return ignoreCommentTag;
    }

    /**
     * Sets whether to ignore comment tags.
     * @param ignoreCommentTag true to ignore comment tags, false otherwise.
     */
    public void setIgnoreCommentTag(final boolean ignoreCommentTag) {
        this.ignoreCommentTag = ignoreCommentTag;
    }

    <function-signature>java.lang.String html(boolean)</function-signature>
    <example>
      ${fe:html(true)}...${fe:html(false)}
    </example>
  </function>

  <function>
    <description>
      Returns a label name.
    </description>
    <name>labelexists</name>
    <function-class>org.codelibs.fess.taglib.FessFunctions</function-class>
    <function-signature>java.lang.Boolean labelExists(java.lang.String)</function-signature>

   *
   * <p><b>Java 21+ users:</b> use {@link Thread.Builder.OfPlatform#daemon(boolean)} instead.
   *
   * @param daemon whether or not new Threads created with this ThreadFactory will be daemon threads
   * @return this for the builder pattern
   */
  @CanIgnoreReturnValue
  public ThreadFactoryBuilder setDaemon(boolean daemon) {
    this.daemon = daemon;
    return this;
  }

  /**

  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  CollectionFuture(
      ImmutableCollection<? extends ListenableFuture<? extends V>> futures,
      boolean allMustSucceed) {
    super(futures, allMustSucceed, true);

    List<@Nullable Present<V>> values =
        futures.isEmpty()
            ? Collections.<@Nullable Present<V>>emptyList()

  val isOptional: Boolean = false,
  /** The value to return if this value is absent. Undefined unless this is optional. */
  val defaultValue: T? = null,
  /** True to set the encoded or decoded value as the type hint for the current SEQUENCE. */
  private val typeHint: Boolean = false,
) : DerAdapter<T> {
  init {
    require(tagClass >= 0)
    require(tag >= 0)
  }

    if (planningThrowable != null) throw planningThrowable

    return result
  }

  override fun hasNext(failedConnection: RealConnection?): Boolean =
    deferredPlans.isNotEmpty() || nextPlanIndex < plans.size || autoGeneratePlans

  override fun sameHostAndPort(url: HttpUrl): Boolean = url.host == address.url.host && url.port == address.url.port

  override fun close() {
    factory.close()
  }

  inner class FakePlan(

      return getWithoutCaching(key);
    } else {
      return value;
    }
  }

  final @Nullable V getWithoutCaching(Object key) {
    checkNotNull(key);
    return backingMap.get(key);
  }

  final boolean containsKey(@Nullable Object key) {
    return getIfCached(key) != null || backingMap.containsKey(key);
  }

  final Set<K> unmodifiableKeySet() {
    return new AbstractSet<K>() {
      @Override