}

    @Override
    public boolean isTransitive() {
        return delegate.isTransitive();
    }

    @Override
    public ModuleDependency setTransitive(boolean transitive) {
        return delegate.setTransitive(transitive);
    }

    @Override
    @Nullable
    public String getTargetConfiguration() {
        return delegate.getTargetConfiguration();
    }

    @Override

    get() = get().isTransitive


/**
 * See [Configuration.setTransitive].
 */
@Deprecated(deprecationMessage, replaceWith = ReplaceWith("get().setTransitive(t)"), level = DeprecationLevel.HIDDEN)
fun <T : Configuration> NamedDomainObjectProvider<T>.setTransitive(t: Boolean): Configuration =
    get().setTransitive(t)


/**
 * See [Configuration.getDescription].
 */

        def context = Mock(org.gradle.api.internal.artifacts.CachingDependencyResolveContext)
        projectDependency = new DefaultProjectDependency(project, null, true, TestFiles.taskDependencyFactory())
        projectDependency.setTransitive(false)

        when:
        projectDependency.resolve(context)

        then:
        0 * _
    }

    void "is buildable"() {
        def context = Mock(TaskDependencyResolveContext)

            result = dependency.addArtifact(ARTIFACT).
                addArtifact(ARTIFACT_WITH_CLASSIFIERS)
        }
        return result.exclude(WrapUtil.toMap("group", TEST_EXCLUDE_RULE.getGroup())).
                setTransitive(true)
    }

    protected static void assertDependencyDescriptorHasCommonFixtureValues(LocalOriginDependencyMetadata dependencyMetadata, boolean withArtifacts) {

    /**
     * Returns whether this dependency should be resolved including or excluding its transitive dependencies.
     *
     * @see #setTransitive(boolean)
     */
    boolean isTransitive();

    /**
     * Sets whether this dependency should be resolved including or excluding its transitive dependencies. The artifacts

        Configuration configuration = project.getConfigurations().resolvableDependencyScopeUnlocked(getConfigurationName());
        configuration.setVisible(false);
        configuration.setTransitive(true);
        configuration.setDescription("The " + getToolName() + " libraries to be used for this project.");
        getJvmPluginServices().configureAsRuntimeClasspath(configuration);

        ConfigurationContainer configurations = resolutionServices.getConfigurationContainer();
        Configuration configuration = configurations.detachedConfiguration(dependency);
        configuration.setTransitive(false);
        ArtifactView lenientView = configuration.getIncoming().artifactView(view -> {
            view.setLenient(true);
        });
        return lenientView.getArtifacts().getFailures().isEmpty();
    }

You can tell Gradle to disable transitive dependency management for a dependency by setting link:{javadocPath}/org/gradle/api/artifacts/ModuleDependency.html#setTransitive-boolean-[ModuleDependency.setTransitive(boolean)] to `false`.
As a result only the main artifact will be resolved for the declared dependency.

.Disabling transitive dependency resolution for a declared dependency
====

        DependencyHandler dependencyHandler = project.getDependencies();

        Configuration plugins = project.getConfigurations().resolvableDependencyScopeUnlocked(SCALA_COMPILER_PLUGINS_CONFIGURATION_NAME);
        plugins.setTransitive(false);
        jvmPluginServices.configureAsRuntimeClasspath(plugins);

        Configuration zinc = project.getConfigurations().resolvableDependencyScopeUnlocked(ZINC_CONFIGURATION_NAME);
        zinc.setVisible(false);

        given:
        def configuration = conf()

        when:
        configuration.setDescription("description")
        configuration.setVisible(false)
        configuration.setTransitive(false)

        then:
        configuration.description == "description"
        !configuration.visible
        !configuration.transitive
    }

    def excludes() {