throws InterruptedException, ExecutionException {
    return future.getFromAlreadyDoneTrustedFuture();
  }

  static <V extends @Nullable Object> V get(AbstractFuture<V> future, long timeout, TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    checkNotNull(unit);
    return future.getFromAlreadyDoneTrustedFuture();
  }

  private Platform() {}

   * processing an event.
   *
   * @return false when EOF is reached
   */
  @Throws(IOException::class)
  fun processNextEvent(): Boolean {
    var id = lastId
    var type: String? = null
    val data = Buffer()

    while (true) {
      when (source.select(options)) {
        in 0..2 -> {
          completeEvent(id, type, data)
          return true
        }

        in 3..4 -> {

     * @return the Base64-encoded Type 1 message
     * @throws NTLMEngineException if an NTLM engine error occurs
     */
    @Override
    public String generateType1Msg(final String domain, final String workstation) throws NTLMEngineException {
        final Type1Message type1Message = new Type1Message(cifsContext, TYPE_1_FLAGS, domain, workstation);

        responseData.setMimeType("text/html");
        return responseData;
    }

    private ResponseData getTestData2() {
        final ResponseData responseData = new ResponseData();
        responseData.setHttpStatusCode(200);
        responseData.setUrl("https://example.com/");
        responseData.setMimeType("text/html");
        return responseData;
    }

    private ResponseData getTestData3() {

     * to return {@code false}. This mimics an ASCII only client
     */
    private static class OffUnicodeConfig extends BaseConfiguration {
        public OffUnicodeConfig() throws Exception {
            super(true);
        }

        @Override
        public boolean isUseUnicode() {
            return false;
        }
    }

    @Test

     * @return an optional parsed {@link Model} or {@code null} if none could be found
     * @throws ModelParserException if the located model cannot be parsed
     */
    @Nonnull
    default Optional<Model> locateAndParse(@Nonnull Path dir, @Nullable Map<String, ?> options)
            throws ModelParserException {
        return locate(dir).map(s -> parse(s, options));
    }

            final boolean update) {
        final BulkRequestBuilder bulkRequestBuilder = client.prepareBulk();

        final SuggestItem[] mergedItems = mergeItems(items);
        if (mergedItems.length == 0) {
            return new SuggestWriterResult();
        }

        for (final SuggestItem item : mergedItems) {
            final GetResponse getResponse = client.prepareGet().setIndex(index).setId(item.getId()).get(TimeValue.timeValueSeconds(30));

                        if ("fsid".equals(cookie.getName()) && "12345abcde12345ABCDE".equals(cookie.getValue())) {
                            return cookie.getValue();
                        }
                    }
                }
                return null;
            }
        };
        MockletHttpServletRequest request = getMockRequest();

        closeQuietly(jsPath);
    }

    /**
     * Extracts the theme name from the artifact name.
     *
     * @param artifact the theme artifact
     * @return the theme name
     * @throws ThemeException if theme name cannot be determined
     */
    protected String getThemeName(final Artifact artifact) {

     */
    public NegTokenTarg(final byte[] token) throws IOException {
        parse(token);
    }

    /**
     * Gets the negotiation result code
     * @return the result code
     */
    public int getResult() {
        return this.result;
    }

    /**
     * Sets the negotiation result code
     * @param result the result code to set
     */
    public void setResult(final int result) {