/**
     * returns dependencies that were attempted to resolve but failed.
     * If empty then all dependencies are neatly resolved.
     *
     * @return only unresolved dependencies
     */
    Set<UnresolvedDependency> getUnresolvedModuleDependencies();

    /**
     * Returns successfully resolved files. Ignores dependencies or files that cannot be resolved.
     *

        if (edge instanceof UnresolvedDependencyEdge) {
            UnresolvedDependencyEdge unresolved = (UnresolvedDependencyEdge) edge;
            Throwable failure = unresolved.getFailure();
            DefaultSection failures = new DefaultSection("Failures");
            LinkedHashSet<String> uniqueResolutions = new LinkedHashSet<>();

     * @return The resolved dependencies, never {@code null}.
     */
    List<Dependency> getResolvedDependencies();

    /**
     * Gets the dependencies that could not be resolved.
     *
     * @return The unresolved dependencies, never {@code null}.
     */
    List<Dependency> getUnresolvedDependencies();

    /**
     * Gets the errors that occurred while building the dependency graph.
     *

        // verify we inherit the transitive dependency
        eclipseChild2.classpath.collect { it.file.name } == ["test-1.0.jar"]
    }

    def "unresolved dependencies are marked as such"() {
        setup:
        def modelBuilder = createEclipseModelBuilder()

        when:

            if (!(dependencyResult instanceof ResolvedDependencyResult)) {
                UnresolvedDependencyResult unresolved = (UnresolvedDependencyResult) dependencyResult;
                throw new GradleException("Could not map coordinates for " + unresolved.getAttempted().getDisplayName() + ".", unresolved.getFailure());
            }

            if (dependencyResult.isConstraint()) {

                runtimeFunction.function.callByWithErrorHandling(receiverInstance, bindingWithValues, origin.parameterBindings.providesConfigureBlock)
            }

            RuntimeFunctionResolver.Resolution.Unresolved -> error("could not resolve a member function $dataFun call in the owner class $receiverKClass")
        }
    }

    private
    fun objectFromConfiguringLambda(

// all methods of T).

type T interface {
	m() interface {T}
	E
}

var _ int = T.m(nil).m().e()

type E interface {
	e() int
}

// Check that unresolved forward chains are followed
// (see also comment in resolver.go, checker.typeDecl).

var _ int = C.m(nil).m().e()

type A B

type B interface {
	m() interface{C}
	E
}

type C A

            pluginId,
            """
                $extensionClass
                project.extensions.create<TestExtension>("bar")
            """
        )
        configureProjectAndExpectCompileFailure("Unresolved reference: foo")
    }

    @Test
    fun `avoids buildscript recompilation on non ABI change in precompiled script plugin`() {
        val pluginId = "my-plugin"
        withPrecompiledScriptPluginInBuildSrc(

        return id;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public ResolutionState getResolutionState() {
        return ResolutionState.UNRESOLVED;
    }

    @Override
    public Set<? extends RenderableDependency> getChildren() {
        return children;
    }

 */
public interface ResettableConfiguration extends Configuration {

    /**
     * Call this factory (which presumably resolves this Configuration) and then reset the resolution state
     * to the unresolved state, discarding any cached resolution results. No other state is reconfigured.
     * The configuration remains immutable if resolution has already occurred. Any hooks or actions which