}

    static class DependencySpec extends AbstractSection {
        private final String targetConfiguration
        private final Object notation

        DependencySpec(String configuration, Object notation) {
            this.targetConfiguration = configuration
            this.notation = notation
        }

        private String formatNotation(GradleDsl dsl) {

        private final Path projectIdentity;
        private final String targetConfiguration;

        public ResolvedProjectConfiguration(Path projectIdentity, String targetConfiguration) {
            this.projectIdentity = projectIdentity;
            this.targetConfiguration = targetConfiguration;
        }
    }

        assert copiedDependency.group == dependency.group
        assert copiedDependency.name == dependency.name
        assert copiedDependency.version == dependency.version
        assert copiedDependency.targetConfiguration == dependency.targetConfiguration
        assert copiedDependency.transitive == dependency.transitive
        assert copiedDependency.artifacts == dependency.artifacts
        assert copiedDependency.excludeRules == dependency.excludeRules

        d.versionConstraint.requiredVersion == '1.0'
        d.versionConstraint.preferredVersion == ''
        d.versionConstraint.strictVersion == ''
        d.versionConstraint.rejectedVersions == []
        d.targetConfiguration == 'compile'
        d.transitive

        !d.force
        !d.changing
    }

    def "with default configuration"() {
        when:

) {
    dependencies.addProviderConvertible(configuration, dependencyNotation, configurationAction)
}


fun addExternalModuleDependencyTo(
    dependencyHandler: DependencyHandler,
    targetConfiguration: String,
    group: String,
    name: String,
    version: String?,
    configuration: String?,
    classifier: String?,
    ext: String?,
    action: Action<ExternalModuleDependency>?

        VariantGraphResolveState targetConfiguration
    ) {
        ResolutionCandidateAssessor resolutionCandidateAssessor = new ResolutionCandidateAssessor(requestedAttributes, matcher);
        List<AssessedCandidate> assessedCandidates = Collections.singletonList(resolutionCandidateAssessor.assessCandidate(targetConfiguration.getName(), targetConfiguration.getCapabilities(), targetConfiguration.getMetadata().getAttributes()));

        when:
        def projectDependency = factory.createFromMap(projectFinder, mapNotation);

        then:
        projectDependency.getDependencyProject() == projectDummy
        projectDependency.targetConfiguration == "compile"
        projectDependency.isTransitive() == expectedTransitive
    }

    def "fails with decent message if provided map is invalid"() {
        given:

        delegate.version(configureAction)

    override fun getId(): String =
        delegate.id

    override fun getTargetConfiguration(): String? =
        delegate.targetConfiguration

    override fun copy(): org.gradle.api.artifacts.ClientModule =
        delegate.copy()

    override fun attributes(configureAction: Action<in AttributeContainer>): ModuleDependency =

                return;
            }
        }

        calculateTargetConfigurations(targetComponent);
        for (NodeState targetConfiguration : targetNodes) {
            targetConfiguration.addIncomingEdge(this);
        }
        if (!targetNodes.isEmpty()) {
            selector.getTargetModule().removeUnattachedDependency(this);
        }
    }

                )
            }

        val targetConfiguration = configuration
            .copy()
            .apply {
                put(CommonConfigurationKeys.USE_FIR, true)
            }

        val jvmGeneratorExtensions = JvmFir2IrExtensions(targetConfiguration, jvmIrDeserializer)
        val targetFir2IrExtensions = CompilerFacilityFir2IrExtensions(