async.setFuture(inner);
    async.cancel(false);
    assertTrue(inner.isCancelled());
    assertFalse(inner.wasInterrupted());
    assertThrows(CancellationException.class, () -> inner.get());
  }

  public void testCancel_beforeSet() throws Exception {
    SettableFuture<Object> async = SettableFuture.create();
    async.cancel(true);
    assertFalse(async.set(42));
  }

    async.setFuture(inner);
    async.cancel(false);
    assertTrue(inner.isCancelled());
    assertFalse(inner.wasInterrupted());
    assertThrows(CancellationException.class, () -> inner.get());
  }

  public void testCancel_beforeSet() throws Exception {
    SettableFuture<Object> async = SettableFuture.create();
    async.cancel(true);
    assertFalse(async.set(42));
  }

import org.dbflute.mail.send.supplement.async.SMailAsyncStrategy;
import org.dbflute.mail.send.supplement.filter.SMailSubjectFilter;
import org.dbflute.mail.send.supplement.label.SMailLabelStrategy;
import org.dbflute.optional.OptionalThing;
import org.dbflute.util.DfStringUtil;
import org.lastaflute.core.magic.async.AsyncManager;
import org.lastaflute.core.magic.async.ConcurrentAsyncCall;

        bufferIndex += 4;
        this.mid = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        if ( ( this.flags & SMB2_FLAGS_ASYNC_COMMAND ) == SMB2_FLAGS_ASYNC_COMMAND ) {
            // async
            this.async = true;
            this.asyncId = SMBUtil.readInt8(buffer, bufferIndex);
            bufferIndex += 8;
            this.sessionId = SMBUtil.readInt8(buffer, bufferIndex);

        super(config, SMB2_CANCEL);
        setMid(mid);
        setAsyncId(asyncId);
        if ( asyncId != 0 ) {
            addFlags(SMB2_FLAGS_ASYNC_COMMAND);
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#getCreditCost()
     */
    @Override
    public int getCreditCost () {
        return 1;

    // ThreadLocal is not available to GWT, so we always reuse the same
    // instance.  It is always safe to return the same instance because
    // javascript is single-threaded, and only used by blocks that doesn't
    // involve async callbacks.
    return CHAR_BUFFER;
  }

  private Platform() {}

import org.codelibs.fess.sso.SsoAuthenticator;
import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.core.magic.async.AsyncManager;
import org.lastaflute.core.time.TimeManager;
import org.lastaflute.web.login.LoginHandlingResource;
import org.lastaflute.web.login.PrimaryLoginManager;
import org.lastaflute.web.login.TypicalLoginAssist;

import jcifs.util.transport.Response;


/**
 * @author mbechler
 *
 */
public interface CommonServerMessageBlockResponse extends CommonServerMessageBlock, Response {

    /**
     * 
     * @return is an async response
     */
    boolean isAsync ();


    /**
     * 
     * @return the next response
     */
    @Override
    CommonServerMessageBlockResponse getNextResponse ();


    /**

 * which is necessarily blocking. By implementing an {@code InputStream} it allows consumers to
 * "pull" as much data as they can handle, which is more convenient when dealing with flow
 * controlled, async APIs.
 *
 * @author Chris Nokleberg
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
final class ReaderInputStream extends InputStream {
  private final Reader reader;

import org.codelibs.fess.util.GsaConfigParser;
import org.codelibs.fess.util.RenderDataUtil;
import org.codelibs.fess.util.ResourceUtil;
import org.codelibs.fess.util.SearchEngineUtil;
import org.lastaflute.core.magic.async.AsyncManager;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.ActionResponse;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.StreamResponse;