List<IvyArtifactName> artifactNames,
        List<ExcludeMetadata> excludes,
        boolean force, boolean changing, boolean transitive, boolean constraint, boolean endorsing,
        @Nullable String reason
    ) {
        this(selector, dependencyConfiguration, artifactNames, excludes, force, changing, transitive, constraint, endorsing, false, reason);
    }

    public LocalComponentDependencyMetadata(
        ComponentSelector selector,

    /**
     * Resolves the transitive dependencies of the specified project.
     *
     * @param project         The project whose dependencies should be resolved, must not be {@code null}.
     * @param scopesToResolve The dependency scopes that should be resolved, may be {@code null}.
     * @param session         The current build session, must not be {@code null}.

        for (String id : sorter.getDependents(projectId)) {
            if (projectIds.add(id) && transitive) {
                getDownstreamProjects(id, projectIds, transitive);
            }
        }
    }

    public List<MavenProject> getUpstreamProjects(MavenProject project, boolean transitive) {
        Objects.requireNonNull(project, "project cannot be null");

    }

    def 'consumer resolves jar variant of producer with dependencies'() {
        defineVariants(file('transitive'))

        defineVariants(file('direct'))
        file('direct/build.gradle') << '''
            dependencies {
                jarElements project(":transitive")
            }
        '''

        file('producer/build.gradle') << '''
            dependencies {

    def "can consume non-consumable project configuration when substituted as a transitive dependency"() {

        file("included/settings.gradle") << """
            rootProject.name = "transitive"
        """
        file("included/build.gradle") << """
            group = "org"

            task myZip(type: Zip) {
                archiveFileName = "transitive.zip"
                destinationDirectory = layout.buildDirectory

plugins {
    id 'java-library'
}

repositories {
    mavenCentral()
}

// tag::transitive-per-dependency[]
dependencies {
    implementation('com.google.guava:guava:23.0') {
        transitive = false
    }
}
// end::transitive-per-dependency[]

tasks.register('copyLibs', Copy) {
    from configurations.compileClasspath
    into layout.buildDirectory.dir('libs')

package allowed

import (
	_ "k8s.io/kubernetes/cmd/import-boss/testdata/transitive/allowed/a2"
	_ "k8s.io/kubernetes/cmd/import-boss/testdata/transitive/forbidden/f2"
	_ "k8s.io/kubernetes/cmd/import-boss/testdata/transitive/neither/n2"
)

        then:
        runtimeOnly.transitive
        !runtimeOnly.visible
        !runtimeOnly.canBeConsumed
        !runtimeOnly.canBeResolved
        runtimeOnly.extendsFrom == [] as Set

        when:
        def runtimeElements = project.configurations.getByName(JvmConstants.RUNTIME_ELEMENTS_CONFIGURATION_NAME)

        then:
        runtimeElements.transitive
        !runtimeElements.visible

            boolean externalVariant
    ) {

        this.componentId = componentId;
        this.name = name;
        this.transitive = transitive;
        this.visible = visible;
        this.artifacts = artifacts;
        this.hierarchy = hierarchy;
        this.excludes = excludes;
        this.attributes = attributes;

                                "module": "transitive",
                                "version": {
                                    "requires": "1.0"
                                },
                                "thirdPartyCompatibility": {
                                    "artifactSelector": {
                                        "name": "transitive",
                                        "type": "jar",