assertArgumentNotNull("parser", parser);
        assertArgumentNotNull("inputSource", inputSource);
        assertArgumentNotNull("handler", handler);

        try {
            parser.parse(inputSource, handler);
        } catch (final SAXException e) {
            throw new SAXRuntimeException(e);
        } catch (final IOException e) {
            throw new IORuntimeException(e);

    Request request = new Request.Builder()
        .url("https://api.github.com/markdown/raw")
        .post(pipeBody)
        .build();

    streamPrimesToSinkAsynchronously(pipeBody.sink());

    try (Response response = client.newCall(request).execute()) {
      if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

      System.out.println(response.body().string());
    }
  }

        File f1 = getTestFile(
                "src/test/resources/projects/parent-version-range-local-child-project-parent-version-expression/child/pom.xml");

        try {
            getProject(f1);
            fail("Expected 'ProjectBuildingException' not thrown.");
        } catch (final ProjectBuildingException e) {
            assertNotNull(e.getMessage());
        }
    }

        super("HMACT64");
        this.ipad = hmac.ipad;
        this.opad = hmac.opad;
        this.md5 = (MessageDigest) hmac.md5.clone();
    }

    @Override
    public Object clone() {
        try {
            return new HMACT64(this);
        } catch (final CloneNotSupportedException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override

     *
     * @param keyObj the crawler object to track (UrlQueue, StatsKeyObject, String, or Number)
     */
    public void begin(final Object keyObj) {
        getCacheKey(keyObj).ifPresent(key -> {
            try {
                statsCache.get(key);
            } catch (final Exception e) {
                final StringBuilder buf = createStringBuffer(keyObj, getCurrentTimeMillis());

         * proper cleanup regardless of success or failure.
         */
        @Override
        public void run() {
            running = true;
            try {
                process();
            } finally {
                running = false;
                finished = true;
            }
        }

        /**

              future.cancel(true);
              if (!future.isDone()) {
                errorMessage.set("Cancel call exited before future was complete.");
              }
            }
          });
      try {
        future.get();
      } catch (Throwable t) {
        // Ignore, we just wanted to block.
      }
      String error = errorMessage.get();
      assertWithMessage(error).that(error).isNull();
    }

        validateApi(body, messages -> {});
        body.crudMode = CrudMode.CREATE;
        final DuplicateHost duplicateHost = getDuplicateHost(body).map(entity -> {
            try {
                duplicateHostService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);

    }

    public TransferListener getDelegate() {
        return delegate;
    }

    private void feedConsumer() {
        final ArrayList<Exchange> batch = new ArrayList<>(batchMaxSize);
        try {
            while (true) {
                batch.clear();
                if (eventQueue.drainTo(batch, BATCH_MAX_SIZE) == 0) {
                    batch.add(eventQueue.take());
                }

          executor.execute(
              () -> {
                try {
                  startUp();
                  notifyStarted();
                  // If stopAsync() is called while starting we may be in the STOPPING state in
                  // which case we should skip right down to shutdown.
                  if (isRunning()) {
                    try {
                      AbstractExecutionThreadService.this.run();