façon Simple est d'ajouter de la mission explicite de la dépendance dans Projetb:

compileTestJava.dependsOn tasks.getByPath(':ProjectA:testClasses')

il est difficile (mais plus clair) de créer une configuration d'artefact supplémentaire pour ProjectA:

task myTestsJar(type: Jar) { 
  // pack whatever you need...
}

configurations {
  testArtifacts
}

artifacts {
   testArtifacts myTestsJar
}

et ajouter la" dépendance 151930920 "pour ProjectB

apply plugin: 'java'
dependencies {
  compile project(':ProjectA')
  testCompile project(path: ':ProjectA', configuration: 'testArtifacts')
}

je sais que c'est une vieille question mais j'ai juste eu le même problème et j'ai passé du temps à comprendre ce qui se passe. Je suis l'aide de Gradle 1.9. Tous les changements doivent être dans build.gradle "151960920 de ProjectB"

pour l'utilisation des classes d'essai de ProjectA dans les essais de ProjectB:

testCompile files(project(':ProjectA').sourceSets.test.output.classesDir)

pour s'assurer que la propriété sourceSets est disponible pour ProjectA:

evaluationDependsOn(':ProjectA')

pour s'assurer que les classes de test de ProjectA sont effectivement là, quand vous compilez ProjectB:

compileTestJava.dependsOn tasks.getByPath(':ProjectA:testClasses')

j'ai moi-même rencontré ce problème récemment, et l'homme est-ce un problème difficile à trouver des réponses pour.

l'erreur que vous faites est de penser qu'un projet devrait exporter ses éléments de test de la même manière qu'il exporte ses artéfacts primaires et ses dépendances.

ce avec quoi j'ai eu beaucoup plus de succès personnellement était de faire un nouveau projet à Gradle. Dans votre exemple, je l'appellerais

Projet A_Test -> src / main /java

je mettrais dans le src/main/java les fichiers que vous avez actuellement dans le projet a/src/test/java. Faites de toute dépendance testCompile de votre projet une dépendance de compilation du projet A_Test.

ensuite, faire du projet A_Test une dépendance testCompile du projet B.

ce n'est pas logique quand vous venez à elle du point de vue de l'auteur des deux projets, mais je pense qu'il fait beaucoup de sens quand vous pensez projets comme junit et scalatest (et d'autres. Même si ces cadres sont liés aux essais, ils ne sont pas considérés comme faisant partie des cibles "d'essai" dans leurs propres cadres-ils produisent des artéfacts primaires que d'autres projets se trouvent justement à utiliser dans leur configuration d'essai. Vous voulez juste suivre le même modèle.

essayer de faire les autres réponses énumérées ici n'a pas fonctionné pour moi personnellement( en utilisant Grad 1.9), mais j'ai trouvé que le modèle que je décris ici est une solution plus propre de toute façon.

nouvelle solution testJar basée (trnsitive Dependencies supported) disponible en plugin gradle:

https://github.com/hauner/gradle-plugins/tree/master/jartest

https://plugins.gradle.org/plugin/com.github.hauner.jarTest/1.0

à Partir de la documentation

dans le cas où vous avez un multi-projet Gradle construire vous pouvez avoir les dépendances entre sous-projets (ce qui est probablement un indice que votre les projets ne sont pas bien structurés).

par exemple, supposons un projet dont dépend le sous-projet B sur le projet A et B n'a pas seulement une dépendance de compile sur A mais aussi une dépendance de test. Pour compiler et exécuter les tests de B nous avons besoin de quelques classes d'aide aux essais de A.

par défaut gradle ne crée pas un artéfact jar à partir de la construction d'essai la sortie d'un projet.

ce plugin ajoute une configuration testArchives (basée sur testCompile) et une tâche jarTest pour créer un bocal à partir du jeu de sources de test (avec le test de classificateur ajouté au nom du pot). Nous pouvons alors compter en B sur la configuration de testoarchives de A (qui inclura également dépendances transitives).

dans un nous ajouterions le plugin à construire.gradle:

apply plugin: 'com.github.hauner.jarTest'

En B nous de référence de la configuration des testArchives comme ceci:

dependencies {
    ...
    testCompile project (path: ':ProjectA', configuration: 'testArchives') 
}

Veuillez lire la mise à jour ci-dessous.

problèmes similaires décrits par JustACluelessNewbie se produit dans IntelliJ IDEA. Le problème est que la dépendance testCompile project(':core').sourceSets.test.output signifie en fait:"dépend des classes générées par la tâche de construction de gradle". Donc, si vous ouvrez clean project où les classes ne sont pas générées, IDEA ne les reconnaîtra pas et signalera les erreurs.

pour corriger ce problème, vous devez ajouter une dépendance sur les fichiers source de test à côté de la dépendance sur compilé classe.

// First dependency is for IDEA
testCompileOnly files { project(':core').sourceSets.test.java.srcDirs }
// Second is for Gradle
testCompile project(':core').sourceSets.test.output

vous pouvez observer des dépendances reconnues par IDEA dans Module Settings -> Dependencies (test scope) .

Btw. ce n'est pas une bonne solution donc refactoring est à considérer. Gradle lui-même a des sous-projets spéciaux contenant des classes de support de test seulement. Voir https://docs.gradle.org/current/userguide/test_kit.html

mise à jour 2016-06-05 Plus je pense à la solution proposée moins je l'aime. Il y a peu de problèmes avec cela:

1. il crée deux dépendances dans IDEA. Un point pour tester les sources un autre pour les classes compilées. Et il est crucial dans quel ordre ces dépendances sont reconnues par L'idée. Vous pouvez jouer avec en changeant l'ordre des dépendances dans L'onglet Paramètres du Module -> dépendances.
2. en déclarant ces dépendances vous polluez inutilement la structure de dépendance.

alors quelle est la meilleure solution? À mon avis, c'est créer un nouvel ensemble de sources personnalisées et y mettre des classes partagées. En fait, les auteurs du projet Gradle l'ont fait en créant testFixtures source set.

pour le faire, il suffit de:

1. créer un jeu de sources et ajouter les configurations nécessaires. Vérifiez ce plugin de script utilisé dans le projet Gradle: https://github.com/gradle/gradle/blob/master/gradle/testFixtures.gradle

2. déclaration de dépendance dans le projet dépendant:

   dependencies {
       testCompile project(path: ':module-with-shared-classes', configuration: 'testFixturesUsageCompile')
   }
   

3. Import Gradle project pour concevoir et utiliser l'option "create separate module per source set" lors de l'importation.

la solution de Fesler n'a pas fonctionné pour moi, quand j'ai essayé de construire un projet android (gradle 2.2.0). J'ai donc dû référencer manuellement les classes requises:

android {
    sourceSets {
        androidTest {
            java.srcDir project(':A').file("src/androidTest/java")
        }
        test {
            java.srcDir project(':A').file("src/test/java")
        }
    }
}

certaines des autres réponses ont causé des erreurs d'une manière ou d'une autre - Gradle n'a pas détecté de classes de test d'autres projets ou le projet Eclipse avait des dépendances invalides lors de l'importation. Si quelqu'un a le même problème, je suggère d'aller avec:

testCompile project(':core')
testCompile files(project(':core').sourceSets.test.output.classesDir)

la première ligne Force L'Eclipse à relier l'autre projet en tant que dépendance, de sorte que toutes les sources sont incluses et à jour. La seconde permet à Gradle de voir réellement les sources, tout en ne causant aucune dépendance non valide. des erreurs comme testCompile project(':core').sourceSets.test.output .

dans le projet B:

dependencies {
  testCompile project(':projectA').sourceSets.test.output
}

semble fonctionner en 1.7-rc-2

si vous avez des dépendances simulées que vous devez partager entre les tests, vous pouvez créer un nouveau projet projectA-mock et ensuite l'ajouter comme dépendance test à ProjectA et ProjectB :

dependencies {
  testCompile project(':projectA-mock')
}

c'est une solution claire pour partager des dépendances simulées, mais si vous devez exécuter des tests à partir de ProjectA dans ProjectB utilisez une autre solution.

je suis si en retard à la fête (C'est maintenant Gradle v4.4) mais pour quiconque trouve cela:

aller à la construction.gradle de projet B (celui qui a besoin de quelques classes de test à partir d'Un) et d'ajouter le texte suivant:

  android {
    ...
    sourceSets {
    String sharedTestDir = '../module-b/src/test/java'
        test {
            java.srcDir sharedTestDir
        }
    }
   ...
  }

voilà!