}

    void "dynamic method fails for no args"() {
        when:
        dependencyConstraintHandler.someConf()

        then:
        def e = thrown(MissingMethodException)
        e.message.startsWith('Could not find method someConf() for arguments [] on ')
    }

    void "cannot add dependency constraint to unknown configuration"() {
        when:

    }

    void failsWhenNoParameters() {
        when:
        artifactHandler.someConf()

        then:
        def e = thrown(MissingMethodException)
        e.message == "Could not find method someConf() for arguments [] on object of type $DefaultArtifactHandler.name."
    }

    void failsWhenAddingToUnknownConfiguration() {
        when:
        artifactHandler.unknown("someNotation")

        then:

    }

    void "dynamic method fails for no args"() {
        when:
        dependencyHandler.someConf()

        then:
        def e = thrown(MissingMethodException)
        e.message.startsWith('Could not find method someConf() for arguments [] on ')
    }

    void "creates a project dependency from map"() {
        ProjectDependency projectDependency = Mock()

        exclude.getModuleId().getName() == module
        exclude.getArtifact() == null
        exclude.getMatcher() == null

        where:
        configurationName | configurations
        'someConf'        | Collections.singleton('someConf')
        null              | Collections.emptySet()
        ''                | Collections.emptySet()
    }

                compilation("first")
            }}
        """

        buildFile << """
            configurations {
                dependencyScope("someConf")
                resolvable("resolvableConf") {
                    extendsFrom(someConf)
                }
            }

            firstChildComponent.withVariantsFromConfiguration(configurations.firstRuntimeElements) {

                    assert unresolved.size() == 0

                    LenientConfiguration someConf = configurations.someConf.resolvedConfiguration.lenientConfiguration

                    unresolved = someConf.getUnresolvedModuleDependencies()
                    resolved = someConf.getFirstLevelModuleDependencies(Specs.SATISFIES_ALL)

                    assert resolved.size() == 0

        }

        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.candidate("Map with mandatory 'path' and optional 'configuration' key").example("[path: ':someProj', configuration: 'someConf']");
        }
    }

 */

package org.gradle.integtests.resolve

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

/**
 * Tests variant reselection. i.e. anything of the form:
 * <pre>
 *     someConf.incoming.artifactView {
 *         withVariantReselection()
 *     }
 * </pre>
 */
class ArtifactVariantReselectionIntegrationTest extends AbstractIntegrationSpec {

        buildFile << """
configurations {
    ${mavenCentralRepository()}
    someConf {
        allprojects { }
    }
}
assert configurations.names as List == ['repositories', 'someConf'] // side effect is that the configuration is actually created
assert repositories.size() == 1
"""

        expect:
        fails "help"

     * <pre class='autoTested'>
     * copySpec {
     *   from 'source'
     *   into 'destination'
     *   //an example of excluding files from certain configuration:
     *   exclude { it.file in configurations.someConf.files }
     * }
     * </pre>
     *
     * If excludes are not provided, then no files will be excluded. If excludes are provided, then files must not match
     * any exclude pattern to be processed.
     *