/**
 * A {@code DependencyResolutionListener} is notified as dependencies are resolved.
 */
@EventScope(Scope.Build.class)
public interface DependencyResolutionListener {
    /**
     * This method is called immediately before a set of dependencies are resolved.
     *
     * @param dependencies The set of dependencies to be resolved.
     */
    void beforeResolve(ResolvableDependencies dependencies);

    /**

    public MetadataTreeNode(ArtifactMetadata md, MetadataTreeNode parent, boolean resolved, ArtifactScopeEnum scope) {
        if (md != null) {
            md.setArtifactScope(ArtifactScopeEnum.checkScope(scope));
            md.setResolved(resolved);
        }

        this.md = md;
        this.parent = parent;
    }

                    def resolved = compile.firstLevelModuleDependencies

                    assert resolved.size() == 3
                    assert resolved.collect { it.moduleName } == ['hiphop', 'child', 'rock']

                    resolved = compile.getFirstLevelModuleDependencies { true }
                    assert resolved.collect { it.moduleName } == ['hiphop', 'child', 'rock']

        return depth;
    }

    public void setDepth(int depth) {
        this.depth = depth;
    }

    public boolean isResolved() {
        return resolved;
    }

    public void setResolved(boolean resolved) {
        this.resolved = resolved;
    }

    public int getPomOrder() {
        return pomOrder;
    }

    public void setPomOrder(int pomOrder) {
        this.pomOrder = pomOrder;

    def "Older Gradle versions mark all dependencies as resolved"() {
        when:
        def project = loadToolingModel(EclipseProject)
        def allDependencies = project.classpath

        then:
        allDependencies.size() == 2
        allDependencies[0].resolved
        allDependencies[0].attemptedSelector == null
        allDependencies[1].resolved
        allDependencies[1].attemptedSelector == null
    }

  - conditions:
    - lastTransitionTime: fake
      message: Route was valid
      reason: Accepted
      status: "True"
      type: Accepted
    - lastTransitionTime: fake
      message: All references resolved
      reason: ResolvedRefs
      status: "True"
      type: ResolvedRefs
    controllerName: istio.io/gateway-controller
    parentRef:
      group: ""
      kind: Service
      name: httpbin-apple

    def "can query result and failure when resolved successfully"() {
        given:
        result.resolved("result")

        expect:
        result.hasResult()
        result.successful
        result.result == "result"
        result.failure == null
    }

    def "can query failure when resolved with failure"() {
        given:
        def failure = new RuntimeException()

 *
 * @since 3.0
 */
public interface PluginPrefixResult {

    /**
     * The resolved group id for the plugin.
     *
     * @return The resolved group id for the plugin, never {@code null}.
     */
    String getGroupId();

    /**
     * The resolved artifact id for the plugin.
     *
     * @return The resolved artifact id for the plugin, never {@code null}.
     */
    String getArtifactId();

    /**

        carets.flatMap { findReferencesAtCaret(mainFile, it.offset) }.forEach { reference ->
            val resolved = reference.resolve() ?: testServices.assertions.fail { "Could not resolve reference at caret" }
            testServices.assertions.assertTrue(reference.isReferenceTo(resolved))
            testServices.assertions.assertEqualsToTestDataFileSibling(resolved.renderResolvedPsi(testServices))
        }
    }

        when:
        run "printMetadataRulesConfig"

        then:
        output.contains "Resolved: api-1.3.0.jar"
        output.contains "Resolved: lib-1.9.jar"

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("dependencyManagement/customizingResolution-selectionRule")
    def "can run targeted rule sample with #dsl dsl"() {