Comment exécuter des tests d'instrumentation Android à partir d'Eclipse?

Question

essais Actuellement, je suis en cours d'exécution des instrumentations de la ligne de commande de cette façon:

adb shell am instrument -w com.blah.blah/android.test.InstrumentationTestRunner 

est-il un moyen de les exécuter à partir d'Eclipse (avec l'installation automatique de l'application)?

Answer 1

Je n'ai pas pu déterminer le déploiement automatique sur l'émulateur. Cependant, vous pouvez prendre la même commande "adb shell" et créer une configuration de lancement externe. J'ai blogué sur ce même sujet here. Lancer de cette façon est un peu plus intuitif lorsque vous utilisez aussi l'argument "-e debug true".

Cependant, je pense que j'ai obtenu plus de kilométrage du script shell bash (si vous utilisez une bonne plate-forme de développement):

function adbtest() { 
    adb shell am instrument -w -e class blah.package.$1 blah.package.test/android.test.InstrumentationTestRunner; 
} 

De cette façon, quand je veux tester bla. package.FooTest Je ne dois me rappeler de taper:

james@trex:~$ adbtest FooTest 

Answer 2

Je ne sais pas d'un excellent moyen d'exécuter des tests automatiquement à partir d'Eclipse, mais je l'ai mis en place une méthode avant droit de construire automatiquement et le déploiement des tests en utilisant la fourmi.

Mon projet est organisé comme suit:

1. Appelons la racine
2. répertoire racine du projet A l'intérieur, je le build.xml généré par le script activityCreator dans le SDK.
3. J'ai un deuxième projet contenant mes tests situés dans la racine/Tests
   • Ce projet a sa propre AndroidManifest.xml (voir la structure du Android API Demos comme exemple)
   • Ce projet a également sa propre construction .xml

afin de soutenir JUnit dans la racine/tests/build.xml, vous devez ajouter le chemin à JUnit. Une façon de procéder consiste à ajouter le chemin d'accès aux cibles de compilation, dex, debug et release (la version est omise, mais elle nécessite la même modification que celle effectuée par le débogage). De plus dans la cible de la compilation, nous incluons le chemin de ../src:

<!-- Compile this project's .java files into .class files. --> 
<target name="compile" depends="dirs, resource-src, aidl"> 
    <javac encoding="ascii" target="1.5" debug="true" extdirs="" 
      srcdir="src/:../src" 
      destdir="${outdir-classes}" 
      bootclasspath="${android-jar}"> 
     <classpath> 
      <fileset dir="${external-libs}" includes="*.jar"/> 
      <fileset file="${junit-path}"/> 
     </classpath> 
    </javac> 
</target> 

<!-- Convert this project's .class files into .dex files. --> 
<target name="dex" depends="compile"> 
    <echo>Converting compiled files and external libraries into ${outdir}/${dex-file}...</echo> 
    <apply executable="${dx}" failonerror="true" parallel="true"> 
     <arg value="--dex" /> 
     <arg value="--output=${intermediate-dex-ospath}" /> 
     <arg path="${outdir-classes-ospath}" /> 
     <fileset dir="${external-libs}" includes="*.jar"/> 
     <fileset file="${junit-path}"/> 
    </apply> 
</target> 

<!-- Package the application and sign it with a debug key. 
    This is the default target when building. It is used for debug. --> 
<target name="debug" depends="dex, package-res"> 
    <echo>Packaging ${out-debug-package}, and signing it with a debug key...</echo> 
    <exec executable="${apk-builder}" failonerror="true"> 
     <arg value="${out-debug-package-ospath}" /> 
     <arg value="-z" /> 
     <arg value="${resources-package-ospath}" /> 
     <arg value="-f" /> 
     <arg value="${intermediate-dex-ospath}" /> 
     <arg value="-rf" /> 
     <arg value="${srcdir-ospath}" /> 
     <arg value="-rj" /> 
     <arg value="${external-libs-ospath}" /> 
     <arg value="-rj" /> 
     <arg value="${junit-path}" /> 
     <arg value="-nf" /> 
     <arg value="${native-libs-ospath}" /> 
    </exec> 
</target> 

Maintenant, nous pouvons construire deux projets séparément. La touche finale est d'ajouter une nouvelle cible à root/build.xml qui va construire et déployer le projet et tester et exécuter les tests. Pour ce faire, ajoutez la cible suivante à la racine/build.xml:

<target name="tests" depends="reinstall"> 
    <echo>Building and installing tests..</echo> 
    <exec executable="ant" failonerror="true"> 
     <arg value="-f" /> 
     <arg value="tests/build.xml" /> 
     <arg value="reinstall"/> 
    </exec> 
    <mkdir dir="${log-dir}" /> 
    <exec executable="${adb}"> 
    <arg value="shell" /> 
    <arg value="am" /> 
    <arg value="instrument" /> 
    <arg value="-w" /> 
    <arg value="-e" /> 
    <arg value="class" /> 
    <arg value="org.yourproject.AllTests" /> 
    <arg value="org.yourproject.tests/android.test.InstrumentationTestRunner" /> 
    </exec> 
</target> 

Une fois que tout cela est en place, démarrez l'émulateur, et exécuter des tests « fourmis ». Cela va construire, déployer et exécuter vos tests en une seule commande.