import org.gradle.test.fixtures.maven.MavenModule

/**
 * Tests for resolving dependencies at configuration-time in a composite build.
 * These tests demonstrate actual behaviour, not necessarily desired behaviour.
 */
class CompositeBuildConfigurationTimeResolveIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    BuildTestFile buildB
    BuildTestFile buildC

    MavenModule publishedModuleB
    TestFile buildBjar

    doLast {
        val query: ArtifactResolutionQuery = dependencies.createArtifactResolutionQuery()
            .forModule("com.google.guava", "guava", "18.0")
            .withArtifacts(MavenModule::class, MavenPomArtifact::class)
        val result: ArtifactResolutionResult = query.execute()

        result.resolvedComponents.forEach { component ->

 * limitations under the License.
 */

package org.gradle.test.fixtures.maven;

import org.gradle.test.fixtures.resource.RemoteArtifact;

public interface RemoteMavenModule extends MavenModule {
    @Override
    RemoteArtifact getPom();

    @Override
    RemoteArtifact getModuleMetadata();

    @Override
    RemoteArtifact getArtifact();

import org.gradle.integtests.fixtures.resolve.ResolveTestFixture
import org.gradle.test.fixtures.maven.MavenModule

/**
 * Tests for resolving dependency artifacts with substitution within a composite build.
 */
class CompositeBuildCommandLineArgsIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    BuildTestFile buildB
    MavenModule publishedModuleB

    def setup() {

package gradlebuild.performance.generator

class TestProject {
    final String name
    final Object defaults
    Integer sourceFiles
    Integer testSourceFiles
    Integer linesOfCodePerSourceFile
    List<MavenModule> dependencies
    MavenRepository repository;
    Integer subprojectNumber

    TestProject(String name, Object defaults, Integer subprojectNumber = null) {
        this.name = name
        this.defaults = defaults

 * limitations under the License.
 */

package org.gradle.plugin.devel.plugins

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.test.fixtures.maven.MavenModule
import org.gradle.util.internal.GUtil

import static org.gradle.plugin.devel.plugins.JavaGradlePluginPlugin.PLUGIN_UNDER_TEST_METADATA_TASK_NAME

import org.gradle.integtests.fixtures.resolve.ResolveTestFixture
import org.gradle.test.fixtures.maven.MavenModule

// These test cases are motivated by the Guava use case: https://github.com/google/guava/pull/3683
class JavaLibraryPublishedTargetJvmEnvironmentIntegrationTest extends AbstractHttpDependencyResolutionTest {
    ResolveTestFixture resolve
    MavenModule module

    def setup() {
        settingsFile << """

import org.gradle.test.fixtures.Repository
import org.gradle.test.fixtures.file.LeaksFileHandles
import org.gradle.test.fixtures.maven.MavenFileRepository
import org.gradle.test.fixtures.maven.MavenModule
import org.gradle.test.fixtures.plugin.PluginBuilder
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.UnitTestPreconditions
import spock.lang.Issue
import spock.lang.Shared

            }
        }

        transformGraphToDepth(repo.modules, depth)
        repo.setDepth(depth)
        repo.publish()
        repo
    }

    void transformGraphToDepth(List<MavenModule> modules, int depth) {
        def depGroups = modules.groupBy { (int) ((it.artifactId - "artifact").toInteger() / depth) }
        depGroups.each { idx, groupModules ->

        def notRequired = mavenRepo.module("org.test", "ignore-me", "1.0")
        def m1 = mavenRepo.module('org.test', 'm1', '1.0').publish()
        def m2 = mavenRepo.module('org.test', 'm2', '1.0').publish()
        def mavenModule = mavenRepo.module("org.test", "maven", "1.0")
            .dependsOn(m1, scope: "compile")
            .dependsOn(m2, scope: "runtime")
            .dependsOn(notRequired, scope: "test")