Gerade heruntergeladenes Android Studio, das auf der Intellij-Idee basiert.

Wie würde man Tests erstellen?

Ich stelle fest, dass es eine Option zum Erstellen eines Testmoduls gibt, aber dies scheint nichts zu bewirken, sondern nur ein neues Projekt mit src zu erstellen

Ich habe auch versucht, die Tastenkombination STRG + ALT + T zu drücken, um Komponententests für eine vorhandene Klasse zu erstellen, aber es scheint, als würde ich sie in das aktuelle Projekt einfügen wollen. Natürlich hilft das bei TDD nicht

Hat jemand hier irgendwelche Erfahrungen?

Diese Antwort richtet sich an Personen, die gerade erst mit Android-Tests beginnen. Ich werde zwei einfache Beispiele geben, um Ihnen zu zeigen, wie das Testen funktioniert. Wenn Sie die nächsten 10 Minuten mitmachen, können Sie Ihre Tests zu Ihrer eigenen App hinzufügen. Ich denke, Sie werden überrascht sein, wie einfach es ist. Ich war es auf jeden Fall.

Einführung in Android-Tests

Es gibt zwei verschiedene Arten von Tests, die Sie durchführen werden.

• Lokale Unit-Tests. Diese werden lokal auf der JVM (Java Virtual Machine) ausgeführt. Da sie lokal sind, sind sie schnell. Sie können sie verwenden, um die Teile Ihres Codes zu testen, die nur Java und nicht die Android-APIs benötigen. (Manchmal können Sie ein gefälschtes API-Objekt erstellen, um mehr Dinge lokal zu testen. Dies wird als Verspottung bezeichnet . Eine VerspottungContext ist ein Beispiel.)
• Instrumentierte Tests. Diese Tests werden auf einem realen Gerät oder im Emulator ausgeführt. Das macht sie langsamer als die lokalen Tests. Sie sind jedoch flexibler, da Ihnen die vollständige Android-API zur Verfügung steht.

Wenn Sie ein neues Projekt erstellen, werden die folgenden Standardordner angezeigt.

Alles ist bereits da und wartet darauf, dass Sie Ihre Tests erstellen. Es ist alles schon eingerichtet!

So erstellen Sie lokale Komponententests

Öffnen Sie die ExampleUnitTestim obigen Bild gezeigte Datei. es sollte ungefähr so ​​aussehen:

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        assertEquals(4, 2 + 2);
    }
}

Drücken Sie den doppelten grünen Pfeil, um alle Tests auszuführen, oder den einzelnen grünen Pfeil, um nur einen auszuführen. (In diesem Fall gibt es nur einen Test, sodass beide dasselbe tun.)

Es sollte vergehen (solange 2 + 2es noch ist, 4wenn Sie diese Antwort lesen). Herzlichen Glückwunsch, Sie haben gerade Ihren ersten Test durchgeführt!

Machen Sie Ihren eigenen Test

Schreiben wir unseren eigenen Test. Fügen Sie diese Klasse zuerst Ihrem Haupt-App-Projekt hinzu, damit wir etwas testen können:

public class MyClass {
    public int add(int a, int b) {
        return a + b;
    }
}

Ändern Sie nun die addition_isCorrect()Methode in der Testklasse so, dass sie dem folgenden Code entspricht (oder fügen Sie einfach eine andere Methode mit einem anderen Namen hinzu):

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        MyClass myClass = new MyClass();
        int result = myClass.add(2, 2);
        int expected = 4;
        assertEquals(expected, result);
    }
}

Führen Sie es erneut aus und Sie sollten sehen, dass es vorbei ist. Herzlichen Glückwunsch, Sie haben gerade Ihren eigenen ersten Test erstellt! (Nun, ich denke, technisch gesehen war es meins, aber hey, nah genug. Was mir gehört, gehört dir.)

So erstellen Sie instrumentierte Tests

Öffnen Sie die ExampleInstrumentedTestDatei. es sollte ungefähr so ​​aussehen:

@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
    @Test
    public void useAppContext() throws Exception {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        assertEquals("com.example.myapp", appContext.getPackageName());
    }
}

Drücken Sie erneut eine dieser grünen Tasten.

Solange Sie ein echtes Gerät angeschlossen oder den Emulator eingerichtet haben, sollte es gestartet und Ihre App ausgeführt werden. Herzlichen Glückwunsch, Sie haben gerade Ihren ersten instrumentierten Test durchgeführt!

Machen Sie Ihren eigenen Test

Die instrumentierten Tests verwenden Espresso , um die Tests durchzuführen. Es ist wie bei Ihrem eigenen kleinen Roboterbenutzer, dass Sie Ihre App testen lassen können. Sie können festlegen, dass beispielsweise eine Taste gedrückt oder die Eigenschaften einer Textansicht gelesen werden sollen.

Sie können die Anweisungen für die Durchführung des Tests von Hand schreiben. Da wir jedoch gerade erst anfangen, verwenden wir die Funktion zur automatischen Aufzeichnung . Es ist super einfach.

Fügen Sie Ihrer Benutzeroberfläche zunächst eine Schaltfläche hinzu, damit wir mit etwas arbeiten können. Ich war das:

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="com.example.myapp.MainActivity">

    <Button
        android:id="@+id/myButton"
        android:text="Click me"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

</android.support.constraint.ConstraintLayout> 

Drücken Sie dann im Menü auf Ausführen> Espressotest aufzeichnen.

Klicken Sie nach dem Start auf die Schaltfläche im Emulator und wählen Sie zum Abschluss OK im Dialogfeld Aufzeichnen. Der folgende Testcode sollte automatisch generiert werden.

@LargeTest
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {

    @Rule
    public ActivityTestRule<MainActivity> mActivityTestRule = new ActivityTestRule<>(MainActivity.class);

    @Test
    public void mainActivityTest() {
        ViewInteraction appCompatButton = onView(
                allOf(withId(R.id.myButton), withText("Click me"), isDisplayed()));
        appCompatButton.perform(click());
    }
}

Toll! Sie haben gerade Ihren ersten instrumentierten Test erstellt! Das war super einfach. Sie sollten wahrscheinlich eine Behauptung hinzufügen, um es zu einem echten Test zu machen, aber das ist auch mit dem Rekorder ziemlich einfach. Sehen Sie sich dieses Video an an, um etwas tiefer zu gehen.

Weitere Studie

Ich würde mir zuerst die Videos ansehen und dann die Dokumentation durchlesen. Es ist alles ziemlich hilfreich. Der letzte Link führt zu einer Reihe von Artikeln, die einige wichtige Dinge behandeln, über die Sie nachdenken sollten, wenn Sie auswählen, was getestet werden soll.

• Android-Testmuster (kurze Videoserien von Android-Entwicklern)
• Erste Schritte mit dem Testen (Android-Dokumente)
• Drei Schritte zur Codequalität über TDD

Bearbeiten: Ab 0.1.8 wird dies jetzt in der IDE unterstützt . Bitte befolgen Sie die dortigen Anweisungen, anstatt die folgenden Anweisungen zu verwenden.

Nach dem Android Gradle Plugin-Benutzerhandbuch konnte ich Tests in der Befehlszeile ausführen, indem ich die folgenden Schritte für ein neu erstelltes Projekt ausführte (ich habe das Standardpaket 'com.example.myapplication' verwendet):

1. Fügen Sie für die Tests ein Verzeichnis src / instrumentTest / java hinzu
2. Fügen Sie dem Paket com.example.myapplication.test eine Testklasse hinzu (Erweiterung von ActivityTestCase)
3. Starten Sie ein virtuelles Gerät
4. Verwenden Sie in der Befehlszeile (im Verzeichnis MyApplicationProject / MyApplication) den Befehl '../gradlew connectionInstrumentTest'.

Dadurch wurden meine Tests ausgeführt und die Testergebnisse in MyApplicationProject / MyApplication / build / reports / instrumentTests / linked platziert. Ich bin neu im Testen von Android-Apps, aber es scheint gut zu funktionieren.

Innerhalb der IDE können Sie versuchen, dieselbe Testklasse auszuführen. Du musst

1. Aktualisieren Sie build.gradle, um Maven Central als Repo aufzulisten
2. Aktualisieren Sie build.gradle und fügen Sie JUnit 3.8 als instrumentTestCompile-Abhängigkeit hinzu, z. B. instrumentTestCompile 'junit: junit: 3.8'.
3. Verschieben Sie in 'Projektstruktur' JUnit manuell, um in der Abhängigkeitsreihenfolge an erster Stelle zu stehen

Dies schlägt jedoch fehl (dem beim Ausführen der Tests verwendeten Klassenpfad fehlt das Testausgabeverzeichnis). Ich bin mir jedoch nicht sicher, ob dies funktionieren würde, da ich verstehe, dass ein Android-spezifischer Testläufer erforderlich ist.

Ich würde vorschlagen, die Datei gradle.build zu verwenden.

1. Fügen Sie ein src / androidTest / java- Verzeichnis für die Tests hinzu (wie Chris zu erklären beginnt)

2. Öffnen Sie die Datei gradle.build und geben Sie dort Folgendes an:

   android {
   
       compileSdkVersion rootProject.compileSdkVersion
       buildToolsVersion rootProject.buildToolsVersion
   
       sourceSets {
   
           androidTest {
               java.srcDirs = ['androidTest/java']
           }
       }
   }

3. Klicken Sie auf "Projekt mit Gradle-Datei synchronisieren" (oben). Sie sollten jetzt sehen, dass ein Ordner "java" (innerhalb von "androidTest") eine grüne Farbe hat.

4. Jetzt können Sie dort beliebige Testdateien erstellen und ausführen.

Ich denke, dieser Beitrag von Rex St John ist sehr nützlich für Unit-Tests mit Android Studio.

_{(Quelle: rexstjohn.com )}

Android Studio v.2.3.3

Markieren Sie den Codekontext, den Sie testen möchten, und verwenden Sie den Hotkey: CTRL+SHIFT +T

Verwenden Sie die Dialogoberfläche, um die Einrichtung abzuschließen.

Das Testframework soll Ihr Projektpaketlayout spiegeln, um die besten Ergebnisse zu erzielen. Sie können jedoch manuell benutzerdefinierte Tests erstellen, sofern Sie über das richtige Verzeichnis und die richtigen Build-Einstellungen verfügen.

Ab sofort (Studio 0.61) reicht es aus, die richtige Projektstruktur beizubehalten. Es ist nicht erforderlich, ein separates Testprojekt wie in Eclipse zu erstellen (siehe unten).

Android Studio entwickelt sich weiter, sodass die oben genannten Antworten möglicherweise nicht mehr zutreffen. Für die aktuelle Version von Android Studio 1.2.1.1 gibt es ein nettes Tutorial zum Testen unter:

http://evgenii.com/blog/testing-activity-in-android-studio-tutorial-part-1/

Eine der wichtigsten Änderungen scheint zu sein, dass die Testanwendung mit Android Studio in das Anwendungsprojekt integriert ist.

Ich bin nicht sicher, ob dies Ihrem spezifischen Problem hilft, aber ich habe eine Anleitung zum Durchführen von Tests mit einem Gradle-Projekt gefunden. Android Gradle Benutzerhandbuch

Der einfachste Weg, den ich gefunden habe, ist der in meinem folgenden Blog-Beitrag optimierte :

1. Erstellen Sie einen Ordner, in den Sie alle Ihre Komponententests schreiben (vorzugsweise com.example.app.tests).
2. Erstellen Sie eine neue Testklasse (vorzugsweise NameOfClassTestedTests, dh BankAccountLoginActivityTests).
3. Erweitern Sie InstrumentationTestCase
4. Schreiben Sie einen fehlgeschlagenen Komponententest, um sicherzustellen, dass die Konfiguration der Komponententests erfolgreich war
5. Beachten Sie, dass der Name einer Komponententestmethode mit dem Wort „test“ beginnen muss (vorzugsweise testTestedMethodNameExpectedResult (), dh testBankAccountValidationFailedShouldLogout ()).
6. Konfigurieren Sie Ihr Projekt für Unit-Tests:
7. Öffnen Sie das Menü "Ausführen ..." und klicken Sie auf "Konfigurationen bearbeiten".
8. Klicken Sie auf die Schaltfläche +
9. Wählen Sie die Vorlage für Android-Tests aus
10. Geben Sie einen Namen für Ihre Laufkonfiguration ein (vorzugsweise 'AppName Tests').
11. Wählen Sie Ihre App in der Modul-Combobox aus
12. Aktivieren Sie das Optionsfeld "All In Package" (im Allgemeinen möchten Sie diese Option auswählen, da alle Komponententests in allen Testklassen ausgeführt werden).
13. Geben Sie den Namen des Testpakets aus Schritt 1 ein (dh com.example.app.tests).
14. Wählen Sie das Gerät aus, auf dem Sie Ihre Tests ausführen möchten
15. Übernehmen und speichern Sie die Konfiguration
16. Führen Sie Unit-Tests durch (und erwarten Sie einen Fehler):
17. Wählen Sie Ihre neu erstellte Testkonfiguration aus dem Menü Ausführen
18. Klicken Sie auf Ausführen und lesen Sie die Ergebnisse in der Ausgabekonsole

Viel Glück, damit Ihr Code besser lesbar, wartbar und gut getestet wird!

Android Studio war eine Art bewegendes Ziel, zuerst eine Entwicklervorschau und jetzt in der Beta. Der Pfad für die Testklassen im Projekt hat sich im Laufe der Zeit geändert. Unabhängig davon, welche AS-Version Sie verwenden, wird der Pfad in Ihrer IML-Datei deklariert. Derzeit finden Sie mit Version 0.8.3 Folgendes in der inneren IML-Datei:

      <sourceFolder url="file://$MODULE_DIR$/src/androidTest/res" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/resources" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/assets" type="java-test-resource" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/aidl" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/java" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/groovy" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/jni" isTestSource="true" />
  <sourceFolder url="file://$MODULE_DIR$/src/androidTest/rs" isTestSource="true" />

In der IML-Datei erfahren Sie, wo Sie Ihre Testklassen platzieren müssen.

Ab Android Studio 1.1 haben wir offizielle (experimentelle) Unterstützung für das Schreiben von Unit-Tests (Roboelectric funktioniert auch).

Quelle: https://sites.google.com/a/android.com/tools/tech-docs/unit-testing-support

Fügen Sie unten lib in gradle Datei hinzu

 androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
        exclude group: 'com.android.support', module: 'support-annotations'
    })

Erstellen Sie die Klasse HomeActivityTest im androidTest-Verzeichnis und fügen Sie vor dem Ausführen des Tests die Zeichenfolge flurry_api_key und sender_id in die Zeichenfolgendatei ein und ändern Sie den Wert für den Fehler- und Erfolgsfall.

@RunWith(AndroidJUnit4.class)
public class HomeActivityTest
{
    private static final String SENDER_ID = "abc";
    private static final String RELEASE_FLURRY_API_KEY = "xyz";

    @Test
    public void gcmRegistrationId_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(SENDER_ID, appContext.getString(R.string.sender_id));
    }

    @Test
    public void flurryApiKey_isCorrect() throws Exception
    {
        // Context of the app under test.
        Context appContext = InstrumentationRegistry.getTargetContext();

        Assert.assertEquals(RELEASE_FLURRY_API_KEY, appContext.getString(R.string.flurry_api_key));
    }
}