override fun getVersion(): String? =
        delegate.version

    override fun isTransitive(): Boolean =
        delegate.isTransitive

    override fun setTransitive(transitive: Boolean): ModuleDependency =
        delegate.setTransitive(transitive)

    override fun contentEquals(dependency: Dependency): Boolean =
        delegate.contentEquals(dependency)

    }

    @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

        if (actualArtifactType == null) {
            if (classifier != null) {
                actualArtifactType = DependencyArtifact.DEFAULT_TYPE;
            }
        } else {
            moduleDependency.setTransitive(false);
        }
        if (actualArtifactType != null) {
            moduleDependency.addArtifact(new DefaultDependencyArtifact(moduleDependency.getName(),

        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();
    }

        deployConfiguration.setVisible(false);
        deployConfiguration.setTransitive(false);
        deployConfiguration.setDescription("Classpath for deployable modules, not transitive.");