for (NodeState node : nodes) {
            for (EdgeState dependencyEdge : node.getIncomingEdges()) {
                incoming.add(dependencyEdge.getFrom().getComponent());
            }
        }
        return incoming;
    }

    @Override
    public Collection<? extends ModuleVersionIdentifier> getAllVersions() {

		h.Write(Separator)
	}

	if b.push != nil && b.push.AuthnPolicies != nil {
		h.WriteString(b.push.AuthnPolicies.GetVersion())
	}
	h.Write(Separator)

	for _, dr := range b.destinationRule.GetFrom() {
		h.WriteString(dr.Name)
		h.Write(Slash)
		h.WriteString(dr.Namespace)
	}
	h.Write(Separator)

	if b.service != nil {
		h.WriteString(string(b.service.Hostname))
		h.Write(Slash)

        replaceVisitedExpressionWith(result);
    }

    @Override
    public void visitRangeExpression(RangeExpression expr) {
        RangeExpression result = new RangeExpression(
            replaceExpr(expr.getFrom()),
            replaceExpr(expr.getTo()),
            expr.isInclusive()
        );
        result.setType(expr.getType());
        result.setSourcePosition(expr);
        replaceVisitedExpressionWith(result);

    }

    @Override
    public String toString() {
        return String.format("%s -> %s", from.toString(), dependencyMetadata);
    }

    @Override
    public NodeState getFrom() {
        return from;
    }

    @Override
    public DependencyMetadata getDependencyMetadata() {
        return dependencyMetadata;
    }

    /**

        return Stub(DependencyEdge) {
            toString() >> "$requested -> $selected"
            getRequested() >> requested
            getActual() >> selected
            getFrom() >> from
        }
    }

        assert actualSteps == expectedSteps
    }

    private TransformRegistration registration(AttributeContainer from, AttributeContainer to) {
        return Mock(TransformRegistration) {
            getFrom() >> from
            getTo() >> to
            getTransformStep() >> Stub(TransformStep)
        }
    }

    private ResolvedVariant variant(Map<String, Object> attributes) {

        this.listeners.add(copySpecListener);
    }

    @VisibleForTesting
    public Set<Object> getSourcePaths() {
        return sourcePaths.getFrom();
    }

    @Nullable
    public String getDestPath() {
        return destDir == null ? null : PATH_NOTATION_PARSER.parseNotation(destDir);
    }

    @Override
    @Nullable

        workQueue.submit(PmdAction.class, this::setupParameters);
    }

    private void setupParameters(PmdActionParameters parameters) {
        parameters.getAntLibraryClasspath().setFrom(getPmdClasspath());
        parameters.getPmdClasspath().setFrom(getPmdClasspath());
        parameters.getTargetJdk().set(getTargetJdk());
        parameters.getRuleSets().set(getRuleSets());
        parameters.getRuleSetConfigFiles().from(getRuleSetFiles());

                resolutionData.getTypeHierarchyAnalysisResult().setFrom(typeHierarchyAnalysisResult);
                resolutionData.getTypeHierarchyAnalysisResult().finalizeValueOnRead();
            }

            @Override
            public void setOriginalClasspath(FileCollection originalClasspath) {
                resolutionData.getOriginalClasspath().setFrom(originalClasspath);

        });
        workQueue.submit(CheckstyleAction.class, this::setupParameters);
    }

    private void setupParameters(CheckstyleActionParameters parameters) {
        parameters.getAntLibraryClasspath().setFrom(getCheckstyleClasspath());
        parameters.getConfig().set(getConfigFile());
        parameters.getMaxErrors().set(getMaxErrors());
        parameters.getMaxWarnings().set(getMaxWarnings());