*/
    fun DependencyHandler.`api`(
        dependencyNotation: String,
        dependencyConfiguration: Action<ExternalModuleDependency>
    ): ExternalModuleDependency = addDependencyTo(
        this, "api", dependencyNotation, dependencyConfiguration
    ) as ExternalModuleDependency


    /**
     * Adds a dependency to the 'api' configuration.
     *

    configurationAction: Action<ExternalModuleDependency>
) {
    dependencies.addProvider(configuration, dependencyNotation, configurationAction)
}


fun addConfiguredDependencyTo(
    dependencies: DependencyHandler,
    configuration: String,
    dependencyNotation: ProviderConvertible<*>,
    configurationAction: Action<ExternalModuleDependency>
) {

// tag::configuration-with-dependencies[]
configurations {
    implementation {
        withDependencies { DependencySet dependencies ->
            ExternalModuleDependency dep = dependencies.find { it.name == 'to-modify' } as ExternalModuleDependency
            dep.version {
                strictly "1.2"
            }
        }
    }
}

        implementation.getDependencies().add(getDependencyHandler().create(notation));
    }

    @Override
    public void implementation(Object notation, Action<? super ExternalModuleDependency> action) {
        ExternalModuleDependency dependency = (ExternalModuleDependency) getDependencyHandler().create(notation);
        action.execute(dependency);
        implementation.getDependencies().add(dependency);
    }

 *
 * @return The dependency.
 *
 * @since 7.6
 */
@Incubating
inline fun DependencyHandler.create(dependencyNotation: String, dependencyConfiguration: ExternalModuleDependency.() -> Unit): ExternalModuleDependency =

    (create(dependencyNotation) as ExternalModuleDependency).apply(dependencyConfiguration)


/**
 * Creates a dependency on a client module without adding it to a configuration.
 *

        }.get(ObjectFactory)

        dependencies = of.newInstance(JvmComponentDependencies)
    }

    def "String notation is supported"() {
        def example = Mock(ExternalModuleDependency)
        def example2 = Mock(ExternalModuleDependency)

        when:
        dependencies {
            implementation "com.example:example:1.0"
            implementation("com.example:example:2.0") {

        // Because it's a Provider, this isn't called until evaluation
        verify(dependency, never()).exclude(mapOf("module" to "com.google.guava"))
    }

    @Test
    fun `can use a provider convertible for the dependency declaration`() {
        val dependency = mock<ExternalModuleDependency>()
        val dependencies = newDependencyHandlerMock()

     *
     * @see [DependencyHandler.add]
     */
    inline fun DependencyHandler.classpath(
        dependencyNotation: String,
        dependencyConfiguration: ExternalModuleDependency.() -> Unit
    ): ExternalModuleDependency = add(CLASSPATH_CONFIGURATION, dependencyNotation, dependencyConfiguration)

    /**
     * Adds a dependency to the script classpath.
     *

        }

        val commonsCliDependency = mock<ExternalModuleDependency>(name = "commonsCliDependency")

        val antModule = mock<org.gradle.api.artifacts.ClientModule>(name = "antModule")
        val antLauncherDependency = mock<ExternalModuleDependency>(name = "antLauncherDependency")
        val antJUnitDependency = mock<ExternalModuleDependency>(name = "antJUnitDependency")

    @Override
    public ExternalModuleDependency create(CharSequence dependencyNotation) {
        ExternalModuleDependency dependency = dependencyNotationParser.getStringNotationParser().parseNotation(dependencyNotation.toString());
        injectServices(dependency);
        return dependency;
    }

    @Override