return graphResults.hasAnyFailure();
    }

    @Override
    public void rethrowFailure() throws ResolveException {
        if (!graphResults.hasAnyFailure()) {
            return;
        }

        List<Throwable> failures = new ArrayList<>();
        graphResults.visitFailures(failures::add);
        resolutionHost.rethrowFailure("dependencies", failures);
    }

    @Override

        when:
        def executionResult = forkingGradleHandle.waitForFinish()

        then:
        1 * execHandle.waitForFinish() >> execResult
        0 * execHandle._
        1 * execResult.rethrowFailure()
        1 * execResult.getExitValue() >> SUCCESS_EXIT_VALUE
        1 * resultAssertion.execute(_)
        executionResult instanceof OutputScrapingExecutionResult
    }

            FlushOperationsCommand flushOperationsCommand = new FlushOperationsCommand();
            addToQueue(flushOperationsCommand);
            flushOperationsCommand.await();
        }
        rethrowFailure();
    }

    private void rethrowFailure() {
        failureHandler.onStop();
    }

    private static class FlushOperationsCommand implements Runnable {
        private CountDownLatch latch = new CountDownLatch(1);

    /**
     * Re-throws any failure executing this process.
     *
     * @return this
     * @throws ExecException the execution failure
     */
    ExecResult rethrowFailure() throws ExecException;

    public void waitForExit() {
        getExecHandle().waitForFinish().rethrowFailure();
    }

    private ExecutionResult waitForStop(boolean expectFailure) {
        ExecResult execResult = getExecHandle().waitForFinish();
        if (durationMeasurement != null) {
            durationMeasurement.stop();
        }
        execResult.rethrowFailure(); // nop if all ok

        String output = getStandardOutput();

        return Describables.of(displayName(), type);
    }

    /**
     * Rethrows the provided failures. Does nothing if the list of failures is empty.
     */
    default void rethrowFailure(String type, Collection<Throwable> failures) {
        mapFailure(type, failures).ifPresent(e -> {
            throw e;
        });
    }

            Set<ResolvedArtifactResult> artifactResults = visitor.getArtifacts();
            Set<Throwable> failures = visitor.getFailures();

            if (!lenient) {
                resolutionHost.rethrowFailure("artifacts", failures);
            }
            return new ArtifactSetResult(artifactResults, failures);
        });
    }

    @Override
    public ResolutionHost getResolutionHost() {

     *
     * @throws ArtifactVariantSelectionException subtypes
     */
    private void maybeThrowResolutionFailures(ResolvedFileCollectionVisitor collectingVisitor) {
        if (!lenient) {
            resolutionHost.rethrowFailure("files", collectingVisitor.getFailures());
        }
    }

    @Override
    protected void appendContents(TreeFormatter formatter) {
        formatter.node("contains: " + getDisplayName());
    }

     *
     * <p>This method does nothing when resolution was successful.</p>
     *
     * @throws ResolveException when the resolve was not successful.
     */
    void rethrowFailure() throws ResolveException;

    /**
     * Returns the files for the configuration dependencies.
     *
     * @return The artifact files of the specified dependencies.

                .setStandardOutput(output)
                .workingDir(new File(".").absoluteFile) //does not matter
                .build()
        e.start()
        def result = e.waitForFinish()
        result.rethrowFailure()

        return output.toString()
    }

    private static Object[] killArgs(Long pid, boolean killTree) {
        if (OperatingSystem.current().unix) {
            // start shell, read script from stdin