def c = revision("c")
        traverses root, a
        traverses root, b
        traverses a, c
        doesNotResolve b, c

        when:
        def result = resolve()
        result.rethrowFailure()

        then:
        result.components == ids(root, a, b, c)
    }

    def "honors component replacements"() {
        given:
        def a = revision('a') // a->c

        BuildResult result = new BuildResult(null, null);
        result.rethrowFailure();
    }

    @Test
    public void rethrowsGradleException() {
        Throwable failure = new GradleException();
        BuildResult result = new BuildResult(null, failure);

        try {
            result.rethrowFailure();
            fail();
        } catch (Exception e) {

        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
    }

    }

    @Test
    public void rethrowFailureDoesNothingWhenTaskHasNotExecuted() {
        state.rethrowFailure()
    }

    @Test
    public void rethrowFailureDoesNothingWhenTaskDidNotFail() {
        state.setOutcome(TaskExecutionOutcome.EXECUTED)
        state.rethrowFailure()
    }

    @Test
    public void rethrowsFailureWhenFailureIsRuntimeException() {

        LenientFilesAndArtifactResolveVisitor visitor = new LenientFilesAndArtifactResolveVisitor();
        artifactSetResolver.visitArtifacts(getSelectedArtifacts().getArtifacts(), visitor, resolutionHost);
        resolutionHost.rethrowFailure("files", visitor.getFailures());
        return visitor.files;
    }

    @Override
    @Deprecated
    public Set<File> getFiles(Spec<? super Dependency> dependencySpec) {

            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);

                assertThat(e.message, equalTo("Never received a connection from $execHandle." as String))
            }
        }

        then:
        1 * execHandle.start()
        1 * execResult.rethrowFailure() >> execResult
        1 * execResult.assertNormalExitValue() >> execResult
        1 * execHandle.abort()
        1 * acceptor.stop()
    }

    def startThrowsExceptionOnChildProcessFailureAndCleansUp() {

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

     */
    @Nullable
    Throwable getFailure();

    /**
     * Throws the project failure, if any. Does nothing if the project did not fail.
     */
    void rethrowFailure();