}
            switch (request.resolvedVersionMetadata.getState()) {
                case Failed:
                    failures.add(request.resolvedVersionMetadata.getFailure());
                    if (isCriticalFailure(request.resolvedVersionMetadata.getFailure())) {
                        queue.clear();
                    }
                    break;
                case Missing:
                case Unknown:

        }

        @Nullable
        public DependencySubstitutionInternal getResult() {
            return result;
        }

        @Nullable
        public Throwable getFailure() {
            return failure;
        }

        public boolean hasFailure() {
            return failure != null;
        }
    }

    @Override
    public Set<String> getVersions() throws ModuleVersionResolveException {
        assertHasResult();
        return versions;
    }

    @Override
    public ModuleVersionResolveException getFailure() {
        assertHasResult();
        return failure;
    }

    @Override
    public void listed(Collection<String> versions) {
        reset(State.Listed);

     */
    Set<String> getVersions() throws ModuleVersionResolveException;

    @Override
    @Nullable
    ModuleVersionResolveException getFailure();

    /**
     * Marks the module as having been listed to have the specified versions available.
     */
    void listed(Collection<String> versions);

    /**

public class NoOpProblemDiagnosticsFactory implements ProblemDiagnosticsFactory {
    public static final ProblemDiagnostics EMPTY_DIAGNOSTICS = new ProblemDiagnostics() {
        @Nullable
        @Override
        public Failure getFailure() {
            return null;
        }

        @Nullable
        @Override
        public Throwable getException() {
            return null;
        }

        @Override

    ComponentGraphSpecificResolveState getGraphState() throws ModuleVersionResolveException;

    /**
     * Returns the resolve failure, if any.
     */
    @Override
    @Nullable
    ModuleVersionResolveException getFailure();

        BuildListenerImpl buildListener = new BuildListenerImpl();
        BuildResult result = doRun(outputStream, errorStream, buildListener);
        if (result.getFailure() != null) {
            throw new UnexpectedBuildFailure(result.getFailure());
        }

        return assertResult(new InProcessExecutionResult(buildListener.executedTasks, buildListener.skippedTasks,

                synchronized (this) {
                    // Failed to resolve input artifact, no need to execute
                    transformedSubject = Try.failure(artifact.getFileSource().getValue().getFailure().get());
                    return false;
                }
            }

            Deferrable<Try<TransformStepSubject>> invocation = createInvocation();
            synchronized (this) {

        return selected;
    }

    @Override
    public ComponentSelectionReason getReason() {
        return reason;
    }

    @Override
    public ModuleVersionResolveException getFailure() {
        return failure;
    }

    @Override
    public boolean isConstraint() {
        return constraint;
    }

    @Override
    public Long getFromVariant() {
        return fromVariant;

        return definition;
    }


    @Override
    public List<InternalSolution> getSolutions() {
        return solutions;
    }

    @Nullable
    @Override
    public InternalFailure getFailure() {
        return failure;
    }

    @Override
    public InternalAdditionalData getAdditionalData() {
        return additionalData;
    }