links.map.put("\\", dr);
            DfsReferralDataInternal tmp = dr;
            do {
                /*
                 * Store references to the map and key so that
                 * SmbFile.resolveDfs can re-insert the dr list with
                 * the dr that was successful so that subsequent
                 * attempts to resolve DFS use the last successful
                 * referral first.
                 */

            .map(variant -> dependencyCoordinateResolverFactory
                .createCoordinateResolvers(variant, versionMappingStrategy)
                .map(resolvers -> getDependenciesForVariant(variant, resolvers, coordinates))
            ).collect(Collectors.toList());

        return new MergeProvider<>(parsedVariants).map(variants -> {
            List<MavenDependency> dependencies = new ArrayList<>();

    def serializer = IncludeDirectivesSerializer.INSTANCE

    def "resolves macro with value that is a string constant"() {
        given:
        sourceFile << """
            #define HEADER "hello.h"
            #include HEADER
        """

        expect:
        resolve() == [header]
    }

    def "resolves macro with value that is a system include"() {
        given:
        sourceFile << """

	// LUI + I-type instruction sequence.
	R_RISCV_TLS_LE

	// R_RISCV_GOT_HI20 resolves the high 20 bits of a 32-bit PC-relative GOT
	// address.
	R_RISCV_GOT_HI20

	// R_RISCV_PCREL_HI20 resolves the high 20 bits of a 32-bit PC-relative
	// address.
	R_RISCV_PCREL_HI20

	// R_RISCV_PCREL_LO12_I resolves the low 12 bits of a 32-bit PC-relative
	// address using an I-type instruction.

        ComponentResolvers resolvers = getResolvers(resolveContext, Collections.emptyList());
        DependencyGraphVisitor artifactsGraphVisitor = artifactVisitorFor(artifactsBuilder, resolvers);

        ImmutableList<DependencyGraphVisitor> visitors = ImmutableList.of(failureCollector, resolutionResultBuilder, localComponentsVisitor, artifactsGraphVisitor);
        doResolve(resolveContext, resolvers, false, IS_LOCAL_EDGE, visitors);

Artifacts
    - producer-other.txt''')
    }

    def 'consumer resolves jar variant of producer'() {
        file('consumer/build.gradle') << '''
            resolve {
                expectations = [ 'producer-jar.txt' ]
            }
        '''
        expect:
        succeeds(':consumer:resolve')
    }

    def 'consumer resolves javadoc variant of producer'() {
        file('consumer/build.gradle') << '''

    private final List<Resolver> resolvers;
    private final Map<String, Set<NodeState>> capabilityWithoutVersionToNodes = new HashMap<>();
    private final Deque<CapabilityConflict> conflicts = new ArrayDeque<>();

    public DefaultCapabilitiesConflictHandler(List<Resolver> resolvers) {
        this.resolvers = resolvers;
    }

    @Override

        then:
        test(result)

        where:
        logLevel | test
        "warn"   | { ExecutionResult r -> r.assertOutputContains("Some toolchain resolvers had internal failures: failsOnResolve (Ooops!). " +

        module.publish()
    }

    def initBuild(MavenRepository repo) {
        buildFile.text = """
repositories {
    maven { url '$repo.uri' }
}
"""
    }

    def "resolves and caches source artifacts"() {
        fixture.requestingSource()
                .expectSourceArtifact("sources")
                .prepare()

        when:
        module.pom.expectGet()

        module.adhocVariants().variant('runtime', [color: 'blue']).withModuleMetadata()
        return module
    }

    /**
     * Each project produces 'blue' variants and has a `resolve` task that resolves the 'green' variant. The 'blue' variant will contain
     * whatever is defined by the given closure on the supplied {@link Builder}.