Diese Seite wurde von der Cloud Translation API übersetzt.

Beginnen Sie mit Game Loop-Tests

Es kann schwierig sein, das Testen von Spielen zu automatisieren, wenn Gaming-Apps auf verschiedenen UI-Frameworks erstellt werden. Game Loop-Tests ermöglichen es Ihnen, Ihre nativen Tests in Test Lab zu integrieren und sie einfach auf Geräten Ihrer Wahl auszuführen. Ein Game Loop-Test führt Ihren Test durch Ihre Gaming-App, während die Aktionen eines echten Spielers simuliert werden. Diese Anleitung zeigt Ihnen, wie Sie einen Game Loop-Test durchführen und dann Ihre Testergebnisse in der Firebase-Konsole anzeigen und verwalten.

Abhängig von Ihrer Spiel-Engine können Sie Tests mit Einzel- oder Mehrfachschleifen implementieren. Eine Schleife ist ein vollständiger oder teilweiser Durchlauf Ihres Tests in Ihrer Gaming-App. Spielschleifen können verwendet werden, um:

Führen Sie ein Level Ihres Spiels so aus, wie es ein Endbenutzer spielen würde. Sie können entweder die Eingabe des Benutzers skripten, den Benutzer untätig lassen oder den Benutzer durch eine KI ersetzen, wenn es in Ihrem Spiel sinnvoll ist (z. B. sagen Sie, Sie haben eine Rennwagen-Gaming-App und haben bereits eine KI implementiert. Sie können einfach einen KI-Treiber mit der Eingabe des Benutzers beauftragen).
Führen Sie Ihr Spiel mit der höchsten Qualitätseinstellung aus, um zu sehen, ob Geräte es unterstützen.
Führen Sie einen technischen Test durch (kompilieren Sie mehrere Shader, führen Sie sie aus, überprüfen Sie, ob die Ausgabe wie erwartet ist usw.).

Sie können einen Game Loop-Test auf einem einzelnen Testgerät, einer Reihe von Testgeräten oder auf Test Lab ausführen. Wir empfehlen jedoch nicht, Game Loop-Tests auf virtuellen Geräten auszuführen, da diese niedrigere Grafikbildraten als physische Geräte haben.

Bevor Sie beginnen

Um einen Test zu implementieren, müssen Sie Ihre App zunächst für Game Loop-Tests konfigurieren.

Fügen Sie Ihrer Aktivität in Ihrem App-Manifest einen neuen Intent-Filter hinzu:
```
<activity android:name=".MyActivity">
   <intent-filter>
       <action android:name="com.google.intent.action.TEST_LOOP"/>
       <category android:name="android.intent.category.DEFAULT"/>
       <data android:mimeType="application/javascript"/>
   </intent-filter>
   <intent-filter>
      ... (other intent filters here)
   </intent-filter>
</activity>
```
Dadurch kann Test Lab Ihr Spiel starten, indem es es mit einer bestimmten Absicht auslöst.
Hinweis: Spielschleifen erfordern einen separaten, dedizierten Intent-Filter, der nicht für andere Zwecke verwendet wird. Ihre Aktivität kann andere Absichtsfilter enthalten. Weitere Informationen zu Absichtsfiltern finden Sie auf der <intent-filter>-Referenzseite.

Fügen Sie in Ihrem Code (wir empfehlen innerhalb der onCreate Methodendeklaration) Folgendes hinzu:

Kotlin+KTX

val launchIntent = intent
if (launchIntent.action == "com.google.intent.action.TEST_LOOP") {
    val scenario = launchIntent.getIntExtra("scenario", 0)
    // Code to handle your game loop here
}MainActivity.kt

Java

Intent launchIntent = getIntent();
if(launchIntent.getAction().equals("com.google.intent.action.TEST_LOOP")) {
    int scenario = launchIntent.getIntExtra("scenario", 0);
    // Code to handle your game loop here
}MainActivity.java

Auf diese Weise kann Ihre Aktivität die Absicht überprüfen, die sie startet. Sie können diesen Code auch später hinzufügen, wenn Sie dies bevorzugen (z. B. nach dem erstmaligen Laden Ihrer Spiel-Engine).

Empfohlen: Fügen Sie am Ende des Tests hinzu:
Kotlin+KTX
```
yourActivity.finish()MainActivity.kt
```
Java
```
yourActivity.finish();MainActivity.java
```
Dadurch wird Ihre App geschlossen, wenn der Game Loop-Test abgeschlossen ist. Der Test verlässt sich auf das UI-Framework Ihrer App, um die nächste Schleife zu starten, und das Schließen Ihrer App teilt ihr mit, dass der Test abgeschlossen ist.

Erstellen Sie einen Spielschleifentest und führen Sie ihn aus

Nachdem Sie Ihre App für Game Loop-Tests konfiguriert haben, können Sie sofort einen Test erstellen und ihn in Ihrer Gaming-App ausführen. Sie können einen Test in Test Lab entweder über die Firebase-Konsole oder die gcloud-Befehlszeilenschnittstelle (CLI) oder auf einem lokalen Gerät mit dem Test Loop Manager ausführen.

Auf einem lokalen Gerät ausführen

Der Test Loop Manager von Test Lab ist eine Open-Source-App, mit der Sie Game Loop-Tests integrieren und auf Ihren lokalen Geräten ausführen können. Außerdem kann Ihr Qualitätssicherungsteam dieselben Spielschleifen auf seinen Geräten ausführen.

So führen Sie einen Test auf einem lokalen Gerät mit dem Test Loop Manager aus:

Laden Sie den Test Loop Manager auf ein Telefon oder Tablet herunter und installieren Sie ihn, indem Sie Folgendes ausführen:
```
adb install testloopmanager.apk
```
Öffnen Sie auf Ihrem Gerät die Test Loop Apps- App auf Ihrem Telefon oder Tablet. Die App zeigt eine Liste von Apps auf Ihrem Gerät an, die mit Spielschleifen ausgeführt werden können. Wenn Sie Ihre Gaming-App hier nicht sehen, vergewissern Sie sich, dass Ihr Intent-Filter mit dem im ersten Schritt des Abschnitts „Bevor Sie beginnen“ beschriebenen übereinstimmen.
Wählen Sie Ihre Gaming-App und dann die Anzahl der Schleifen aus, die Sie ausführen möchten. Hinweis: In diesem Schritt können Sie wählen, ob Sie statt nur einer Schleife eine Teilmenge von Schleifen ausführen möchten. Weitere Informationen zum gleichzeitigen Ausführen mehrerer Schleifen finden Sie unter Optionale Funktionen.
Klicken Sie auf Test ausführen . Ihr Test wird sofort ausgeführt.

Im Testlabor ausführen

Sie können einen Game Loop-Test in Test Lab entweder über die Firebase-Konsole oder die gcloud-Befehlszeilenschnittstelle ausführen. Bevor Sie beginnen, öffnen Sie die Firebase-Konsole , falls Sie dies noch nicht getan haben, und erstellen Sie ein Projekt.

Verwenden Sie die Firebase-Konsole

Klicken Sie in der Firebase-Konsole im linken Bereich auf Test Lab .
Klicken Sie auf „Ersten Test ausführen “ (oder „Test ausführen“ , wenn für Ihr Projekt bereits ein Test durchgeführt wurde).
Wählen Sie als Testtyp Spielschleife aus und klicken Sie dann auf Weiter .
Klicken Sie auf Durchsuchen und navigieren Sie dann zur .apk Datei Ihrer App. Hinweis: In diesem Schritt können Sie wählen, ob Sie statt nur einer Schleife eine Teilmenge von Schleifen ausführen möchten. Weitere Informationen zum gleichzeitigen Ausführen mehrerer Schleifen finden Sie unter Optionale Funktionen.
Klicken Sie auf Weiter .
Wählen Sie die physischen Geräte aus, die zum Testen Ihrer App verwendet werden sollen.
Klicken Sie auf Tests starten .

Weitere Informationen zu den ersten Schritten mit der Firebase-Konsole finden Sie unter Starten Sie das Testen mit der Firebase-Konsole.

Verwenden Sie die gcloud-Befehlszeile (CLI)

Falls noch nicht geschehen, laden Sie das Google Cloud SDK herunter und installieren Sie es.
Melden Sie sich mit Ihrem Google-Konto bei der gcloud CLI an:
gcloud auth login
Legen Sie Ihr Firebase-Projekt in gcloud fest, wobei PROJECT_ID die ID Ihres Firebase-Projekts ist:
```
gcloud config set project PROJECT_ID
```
Führen Sie Ihren ersten Test durch:
```
gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23
```
Hinweis: In diesem Schritt können Sie wählen, ob Sie statt nur einer Schleife eine Teilmenge von Schleifen ausführen möchten. Weitere Informationen zum gleichzeitigen Ausführen mehrerer Schleifen finden Sie unter Optionale Funktionen.

Weitere Informationen zu den ersten Schritten mit der gcloud-Befehlszeilenschnittstelle finden Sie unter Testen über die gcloud-Befehlszeile starten.

Optionale Funktionen

Test Lab bietet mehrere optionale Funktionen, mit denen Sie Ihre Tests weiter anpassen können, einschließlich der Möglichkeit, Ausgabedaten zu schreiben, Unterstützung für mehrere Spielschleifen und Beschriftungen für verwandte Schleifen.

Ausgangsdaten schreiben

Ihr Game Loop-Test kann die Ausgabe in eine Datei schreiben, die in der Methode launchIntent.getData() angegeben ist. Nachdem Sie einen Test ausgeführt haben, können Sie auf diese Ausgabedaten im Abschnitt „Testlabor“ der Firebase-Konsole zugreifen (siehe Beispiel für eine Game Loop-Testausgabedatei ).

Test Lab befolgt Best Practices zum Freigeben einer Datei zwischen Apps, die unter Freigeben einer Datei beschrieben werden. In der Methode onCreate() Ihrer Aktivität, in der sich Ihre Absicht befindet, können Sie Ihre Datenausgabedatei überprüfen, indem Sie den folgenden Code ausführen:

Kotlin+KTX

val launchIntent = intent
val logFile = launchIntent.data
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    // ...
}MainActivity.kt

Java

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    // ...
}MainActivity.java

Wenn Sie von der C++-Seite Ihrer Spiele-App in die Datei schreiben möchten, können Sie den Dateideskriptor anstelle des Dateipfads übergeben:

Kotlin+KTX

val launchIntent = intent
val logFile = launchIntent.data
var fd = -1
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    fd = try {
        contentResolver
            .openAssetFileDescriptor(logFile, "w")!!
            .parcelFileDescriptor
            .fd
    } catch (e: FileNotFoundException) {
        e.printStackTrace()
        -1
    } catch (e: NullPointerException) {
        e.printStackTrace()
        -1
    }
}

// C++ code invoked here.
// native_function(fd);MainActivity.kt

Java

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
int fd = -1;
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    try {
        fd = getContentResolver()
                .openAssetFileDescriptor(logFile, "w")
                .getParcelFileDescriptor()
                .getFd();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        fd = -1;
    } catch (NullPointerException e) {
        e.printStackTrace();
        fd = -1;
    }
}

// C++ code invoked here.
// native_function(fd);MainActivity.java

C++

#include <unistd.h>
JNIEXPORT void JNICALL
Java_my_package_name_MyActivity_native_function(JNIEnv *env, jclass type, jint log_file_descriptor) {
// The file descriptor needs to be duplicated.
int my_file_descriptor = dup(log_file_descriptor);
}

Beispiel für eine Ausgabedatei

Sie können Ausgabedatendateien (wie im Beispiel unten formatiert) verwenden, um die Testergebnisse der Spielschleife im Abschnitt „Testlabor“ der Firebase-Konsole anzuzeigen. Bereiche, die als /.../ angezeigt werden, können alle benutzerdefinierten Felder enthalten, die Sie benötigen, solange sie nicht mit den Namen anderer Felder in Konflikt stehen, die in dieser Datei verwendet werden:

{
  "name": "test name",
  "start_timestamp": 0, // Timestamp of the test start (in us).
                           Can be absolute or relative
  "driver_info": "...",
  "frame_stats": [
    {
      "timestamp": 1200000, // Timestamp at which this section was written
                               It contains value regarding the period
                               start_timestamp(0) -> this timestamp (1200000 us)
      "avg_frame_time": 15320, // Average time to render a frame in ns
      "nb_swap": 52, // Number of frame rendered
      "threads": [
        {
          "name": "physics",
          "Avg_time": 8030 // Average time spent in this thread per frame in us
        },
        {
          "name": "AI",
          "Avg_time": 2030 // Average time spent in this thread per frame in us
        }
      ],
      /.../ // Any custom field you want (vertices display on the screen, nb units …)
    },
    {
      // Next frame data here, same format as above
    }
  ],
  "loading_stats": [
    {
      "name": "assets_level_1",
      "total_time": 7850, // in us
      /.../
    },
    {
      "name": "victory_screen",
      "total_time": 554, // in us
      /.../
    }

  ],
  /.../, // You can add custom fields here
}

Mehrere Spielschleifen

Möglicherweise finden Sie es nützlich, mehrere Spielschleifen in Ihrer App auszuführen. Eine Schleife ist ein vollständiger Durchlauf Ihrer Spiele-App von Anfang bis Ende. Wenn Sie beispielsweise mehrere Level in Ihrem Spiel haben, möchten Sie möglicherweise eine Spielschleife haben, um jedes Level zu starten, anstatt eine Schleife zu haben, die alle durchläuft. Auf diese Weise können Sie, wenn Ihre App auf Level 32 abstürzt, diese Spielschleife direkt starten, um den Absturz zu reproduzieren und Fehlerbehebungen zu testen.

So aktivieren Sie Ihre App, um mehrere Schleifen gleichzeitig auszuführen:

Wenn Sie einen Test mit dem Test Loop Manager ausführen:
1. Fügen Sie dem Manifest Ihrer App innerhalb des <application> -Elements die folgende Zeile hinzu:
```
<meta-data
  android:name="com.google.test.loops"
  android:value="5" />
```
  Diese Startabsicht enthält die Zielschleife als ganzzahligen Parameter. Im Feld android:value können Sie eine Ganzzahl von 1 bis 1024 angeben (die maximal zulässige Anzahl von Schleifen für einen einzelnen Test). Beachten Sie, dass Schleifen beginnend bei 1 und nicht bei 0 indiziert werden.
2. In der Test Loop Manager-App wird ein Auswahlbildschirm angezeigt, auf dem Sie auswählen können, welche Schleife(n) Sie ausführen möchten. Wenn Sie mehrere Schleifen auswählen, wird jede Schleife der Reihe nach gestartet, nachdem die vorhergehende Schleife abgeschlossen ist.
Wenn Sie einen Test mit der Firebase-Konsole ausführen, geben Sie eine Liste oder einen Bereich von Schleifennummern in das Feld „Szenarien“ ein.
Wenn Sie einen Test mit der gcloud-Befehlszeilenschnittstelle ausführen, geben Sie mithilfe des Flags --scenario-numbers eine Liste mit Schleifennummern an. Beispielsweise führt --scenario-numbers=1,3,5 die Schleifen 1, 3 und 5 aus.
Wenn Sie C++ schreiben und das Verhalten Ihrer Schleife ändern möchten, übergeben Sie das folgende Extra an Ihren nativen C++-Code:
Kotlin+KTX
```
val launchIntent = intent
val scenario = launchIntent.getIntExtra("scenario", 0)MainActivity.kt
```
Java
```
Intent launchIntent = getIntent();
int scenario = launchIntent.getIntExtra("scenario", 0);MainActivity.java
```
Sie können jetzt das Verhalten Ihrer Schleife basierend auf dem resultierenden int Wert ändern.

Spielschleifen beschriften

Wenn Sie Ihre Spielschleifen mit einer oder mehreren Szenariobezeichnungen kennzeichnen, können Sie und Ihr QA-Team problemlos eine Reihe verwandter Spielschleifen starten (z. B. „alle kompatiblen Spielschleifen“) und diese in einer einzigen Matrix testen. Sie können Ihre eigenen Etiketten erstellen oder die von Test Lab angebotenen vordefinierten Etiketten verwenden:

com.google.test.loops.player_experience : Für Schleifen, die verwendet werden, um die Erfahrung eines echten Benutzers beim Spielen des Spiels zu reproduzieren. Das Ziel des Testens mit diesen Schleifen besteht darin, Probleme zu finden, auf die ein echter Benutzer beim Spielen des Spiels stoßen würde.
com.google.test.loops.gpu_compatibility : For-Schleifen zum Testen von GPU-bezogenen Problemen. Das Ziel des Testens mit diesen Schleifen besteht darin, GPU-Code auszuführen, der in der Produktion möglicherweise nicht ordnungsgemäß ausgeführt wird, um Probleme mit Hardware und Treibern aufzudecken.
com.google.test.loops.compatibility : For-Schleifen zum Testen einer breiten Palette von Kompatibilitätsproblemen, einschließlich I/O-Problemen und OpenSSL-Problemen.
com.google.test.loops.performance : Für Schleifen, die zum Testen der Leistung des Geräts verwendet werden. Beispielsweise kann ein Spiel mit den komplexesten Grafikeinstellungen ausgeführt werden, um zu sehen, wie sich ein neues Gerät verhält.

So aktivieren Sie Ihre App, um Schleifen mit demselben Label auszuführen:

Wenn Sie einen Test mit dem Test Loop Manager ausführen:
1. Fügen Sie im Manifest Ihrer App die folgende Metadatenzeile hinzu und ersetzen Sie LABEL_NAME durch ein Label Ihrer Wahl:
```
<meta-data
 android:name="com.google.test.loops.LABEL_NAME"
 android:value="1,3-5" />
```
  Im Feld android:value können Sie einen Bereich oder eine Reihe von Ganzzahlen von 1 bis 1024 (die maximal zulässige Anzahl von Schleifen für einen einzelnen Test) angeben, die die Schleifen darstellen, die Sie kennzeichnen möchten. Beachten Sie, dass Schleifen beginnend bei 1 und nicht bei 0 indiziert werden. Zum Beispiel wendet android:value="1,3-5" LABEL_NAME auf die Schleifen 1, 3, 4 und 5 an.
2. Geben Sie in der Test Loop Manager-App eine oder mehrere Bezeichnungen in das Feld Bezeichnungen ein.
Wenn Sie einen Test mit der Firebase-Konsole ausführen, geben Sie ein oder mehrere Labels in das Feld Labels ein.
Wenn Sie einen Test mit der gcloud-Befehlszeilenschnittstelle ausführen, geben Sie mithilfe des Flags --scenario-labels ein oder mehrere Szenario-Labels an (z. B. --scenario-labels=performance,gpu ).

Unterstützung bei der App-Lizenzierung

Test Lab unterstützt Apps, die den von Google Play angebotenen App-Lizenzierungsdienst verwenden. Um die Lizenzierung beim Testen Ihrer App mit Test Lab erfolgreich zu überprüfen, müssen Sie Ihre App im Produktionskanal im Play Store veröffentlichen. Um Ihre App im Alpha- oder Betakanal mit Test Lab zu testen, entfernen Sie die Lizenzprüfung, bevor Sie Ihre App in Test Lab hochladen.

Bekannte Probleme

Game Loop-Tests in Test Lab weisen die folgenden bekannten Probleme auf:

Einige Abstürze unterstützen keine Backtraces. Beispielsweise können einige Release-Builds die Ausgabe des debuggerd Prozesses mit prctl(PR_SET_DUMPABLE, 0) unterdrücken. Weitere Informationen finden Sie debuggerd .
API Level 19 wird derzeit aufgrund von Dateiberechtigungsfehlern nicht unterstützt.