Spielschleifentest ausführen

Es kann schwierig sein, Spieletests zu automatisieren, wenn Gaming-Apps auf verschiedenen UI-Frameworks basieren. Mit Game Loop-Tests können Sie Ihre nativen Tests in Test Lab einbinden und ganz einfach auf ausgewählten Geräten ausführen. In diesem Leitfaden wird beschrieben, wie Sie einen Game Loop-Test für die Ausführung mit Firebase Test Lab vorbereiten.

Spielschleifentests

Bei einem Game Loop-Test werden die Aktionen eines echten Spielers simuliert, um schnell und skalierbar zu prüfen, ob Ihr Spiel für Ihre Nutzer eine gute Leistung erbringt. Ein Loop ist ein vollständiger oder teilweiser Durchlauf Ihres Tests in Ihrer Gaming-App. Sie können einen Game Loop-Test lokal in einem Simulator oder auf einer Reihe von Geräten in Test Lab ausführen. Mit Spielschleifentests können Sie Folgendes tun:

  • Spielen Sie Ihr Spiel so durch, wie es ein Endnutzer tun würde. Sie können die Eingabe des Nutzers entweder skripten, den Nutzer inaktiv lassen oder den Nutzer durch eine KI ersetzen. Wenn Sie beispielsweise KI in einem Autorennen implementiert haben, können Sie einen KI-Fahrer für die Eingabe des Nutzers verantwortlich machen.
  • Spielen Sie Ihr Spiel mit der höchsten Qualitätseinstellung, um herauszufinden, welche Geräte es unterstützen.
  • Führen Sie einen technischen Test durch, z. B. kompilieren Sie mehrere Shader, führen Sie sie aus und prüfen Sie, ob die Ausgabe wie erwartet ist.

Schritt 1: Benutzerdefiniertes URL-Schema für Test Lab registrieren

  1. Wählen Sie in Xcode ein Projektziel aus.

  2. Klicken Sie auf den Tab Info und fügen Sie einen neuen URL-Typ hinzu.

  3. Geben Sie im Feld URL-Schemas firebase-game-loop ein. Sie können das benutzerdefinierte URL-Schema auch registrieren, indem Sie es der Info.plist-Konfigurationsdatei Ihres Projekts an einer beliebigen Stelle innerhalb des <dict>-Tags hinzufügen:

    <key>CFBundleURLTypes</key>
 <array>
     <dict>
         <key>CFBundleURLName</key>
         <string></string>
         <key>CFBundleTypeRole</key>
         <string>Editor</string>
         <key>CFBundleURLSchemes</key>
         <array>
             <string>firebase-game-loop</string>
         </array>
     </dict>
 </array>

Ihre App ist jetzt für die Ausführung eines Tests mit Test Lab konfiguriert.

Schritt 2: Optionale Konfiguration der App

Mehrere Schleifen ausführen

Wenn Sie in Ihrem Test mehrere Schleifen (d. h. Szenarien) ausführen möchten, müssen Sie beim Start angeben, welche Schleifen in Ihrer App ausgeführt werden sollen.

Überschreiben Sie in Ihrem App-Delegate die Methode application(_:open:options:):

SwiftObjective-C 
func application(_app: UIApplication,
                 open url: URL
                 options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
    let components = URLComponents(url: url, resolvingAgainstBaseURL: true)!
    if components.scheme == "firebase-game-loop" {
        // ...Enter Game Loop Test logic to override application(_:open:options:).
    }
    return true
}

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary &lt;UIApplicationOpenURLOptionsKey, id&gt; *)options {
  if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
      // ...Enter Game Loop Test logic to override application(_:open:options:).
  }
}

Wenn Sie mehrere Schleifen in Ihrem Test ausführen, wird die aktuelle Schleife als Parameter an die URL übergeben, mit der die App gestartet wird. Sie können die aktuelle Schleifennummer auch durch Parsen des URLComponents-Objekts abrufen, das zum Abrufen des benutzerdefinierten URL-Schemas verwendet wird:

SwiftObjective-C 
if components.scheme == "firebase-game-loop" {
    // Iterate over all parameters and find the one with the key "scenario".
    let scenarioNum = Int(components.queryItems!.first(where: { $0.name == "scenario" })!.value!)!
    // ...Write logic specific to the current loop (scenarioNum).
}

if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
    // Launch the app as part of a game loop.
    NSURLComponents *components = [NSURLComponents componentsWithURL:url
                                             resolvingAgainstBaseURL:YES];
    for (NSURLQueryItem *item in [components queryItems]) {
        if ([item.name isEqualToString:@"scenario"]) {
            NSInteger scenarioNum = [item.value integerValue];
            // ...Write logic specific to the current loop (scenarioNum).
        }
    }
}

Test vorzeitig beenden

Standardmäßig wird ein Spielschleifentest so lange ausgeführt, bis ein Zeitlimit von fünf Minuten erreicht wird, auch wenn alle Schleifen bereits ausgeführt wurden. Wenn das Zeitlimit erreicht ist, wird der Test beendet und alle ausstehenden Schleifen abgebrochen. Sie können den Test beschleunigen oder vorzeitig beenden, indem Sie das benutzerdefinierte URL-Schema von Test Labfirebase-game-loop-complete in der AppDelegate-Datei Ihrer App aufrufen. Beispiel:

SwiftObjective-C 
/// End the loop by calling our custom url scheme.
func finishLoop() {
    let url = URL(string: "firebase-game-loop-complete://")!
    UIApplication.shared.open(url)
}

- (void)finishLoop {
  UIApplication *app = [UIApplication sharedApplication];
  [app openURL:[NSURL URLWithString:@"firebase-game-loop-complete://"]
      options:@{}
completionHandler:^(BOOL success) {}];
}

Ihr Spielschleifentest beendet die aktuelle Schleife und führt die nächste aus. Wenn keine Schleifen mehr ausgeführt werden müssen, endet der Test.

Benutzerdefinierte Testergebnisse schreiben

Sie können Ihren Game Loop-Test so konfigurieren, dass benutzerdefinierte Testergebnisse in das Dateisystem Ihres Geräts geschrieben werden. So speichert Test Lab beim Starten des Tests die Ergebnisdateien in einem GameLoopsResults-Verzeichnis auf Ihrem Testgerät, das Sie selbst erstellen müssen. Nach dem Test verschiebt Test Lab alle Dateien aus dem Verzeichnis GameLoopResults in den Bucket Ihres Projekts. Beachten Sie beim Einrichten des Tests Folgendes:

  • Alle Ergebnisdateien werden unabhängig von Dateityp, Größe oder Anzahl hochgeladen.

  • Test Lab verarbeitet Ihre Testergebnisse erst, wenn alle Schleifen in Ihrem Test abgeschlossen sind. Wenn Ihr Test also mehrere Schleifen enthält, die Ausgabe schreiben, müssen Sie sie einer einzelnen Ergebnisdatei anhängen oder für jede Schleife eine Ergebnisdatei erstellen. So können Sie verhindern, dass Ergebnisse aus einer vorherigen Schleife überschrieben werden.

So richten Sie Ihren Test so ein, dass benutzerdefinierte Testergebnisse geschrieben werden:

  1. Erstellen Sie im Verzeichnis Documents Ihrer App ein Verzeichnis mit dem Namen GameLoopResults.

  2. Fügen Sie an einer beliebigen Stelle im Code Ihrer App (z.B. in Ihrem App-Delegate) Folgendes hinzu:

    SwiftObjective-C 
    /// Write to a results file.
func writeResults() {
  let text = "Greetings from game loops!"
  let fileName = "results.txt"
  let fileManager = FileManager.default
  do {

  let docs = try fileManager.url(for: .documentDirectory,
                                 in: .userDomainMask,
                                 appropriateFor: nil,
                                 create: true)
  let resultsDir = docs.appendingPathComponent("GameLoopResults")
  try fileManager.createDirectory(
      at: resultsDir,
      withIntermediateDirectories: true,
      attributes: nil)
  let fileURL = resultsDir.appendingPathComponent(fileName)
  try text.write(to: fileURL, atomically: false, encoding: .utf8)
  } catch {
    // ...Handle error writing to file.
  }
}

    /// Write to a results file.
- (void)writeResults:(NSString *)message {
    // Locate and create the results directory (if it doesn't exist already).
    NSFileManager *manager = [NSFileManager defaultManager];
    NSURL* url = [[manager URLsForDirectory:NSDocumentDirectory
                                  inDomains:NSUserDomainMask] lastObject];
    NSURL* resultsDir = [url URLByAppendingPathComponent:@"GameLoopResults"
                                             isDirectory:YES];
    [manager createDirectoryAtURL:resultsDir
      withIntermediateDirectories:NO
                       attributes:nil
                            error:nil];

    // Write the result message to a text file.
    NSURL* resultFile = [resultsDir URLByAppendingPathComponent:@"result.txt"];
    if ([manager fileExistsAtPath:[resultFile path]]) {
        // Append to the existing file
        NSFileHandle *handle = [NSFileHandle fileHandleForWritingToURL:resultFile
                                                                 error:nil];
        [handle seekToEndOfFile];
        [handle writeData:[message dataUsingEncoding:NSUTF8StringEncoding]];
        [handle closeFile];
    } else {
        // Create and write to the file.
        [message writeToURL:resultFile
                 atomically:NO
                   encoding:NSUTF8StringEncoding error:nil];
    }
}

Schritt 3: App signieren

  1. Achten Sie darauf, dass alle Artefakte in der App signiert sind. Sie können dies beispielsweise über Xcode tun, indem Sie Signatureinstellungen wie das Bereitstellungsprofil und die Identität angeben. Weitere Informationen finden Sie unter Apple-Codierung.

Schritt 4: App für den Upload verpacken

Erstellen Sie eine IPA-Datei für Ihre App. Sie müssen sie später finden.

  1. Klicken Sie im Drop-down-Menü auf Produkt > Archivieren. Wählen Sie das neueste Archiv aus und klicken Sie dann auf App verteilen.

  2. Klicken Sie im angezeigten Fenster auf Entwicklung > Weiter.

  3. Optional:Wenn Sie einen schnelleren Build erhalten möchten, deaktivieren Sie die Option Aus Bitcode neu erstellen und klicken Sie dann auf Weiter. Test Lab erfordert keine App-Optimierung oder Neukompilierung, um einen Test durchzuführen. Sie können diese Option also bedenkenlos deaktivieren.

  4. Klicken Sie auf Exportieren und geben Sie ein Verzeichnis ein, in das Sie die IPA-Datei Ihrer App herunterladen möchten.

Schritt 5: App-Signatur überprüfen

  1. Prüfen Sie die App-Signatur, indem Sie die .ipa-Datei entpacken und dann codesign --verify --deep --verbose /path/to/MyApp.app ausführen. Dabei ist „MeineApp“ der Name der App im entpackten Ordner (variiert je nach Projekt). Die erwartete Ausgabe ist MyApp.app: valid on disk.

Schritt 6: Test lokal ausführen

Sie können den Test lokal ausführen, um sein Verhalten zu prüfen, bevor Sie ihn mit Test Lab ausführen. Wenn Sie die Anwendung lokal testen möchten, laden Sie sie in einen Simulator und führen Sie Folgendes aus:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://

  • Sie können die UDID Ihres Simulators mit dem Befehl instruments -s devices ermitteln.

  • Wenn nur ein Simulator ausgeführt wird, geben Sie anstelle von SIMULATOR_UDID den speziellen String "booted" ein.

Wenn Ihr Test mehrere Schleifen enthält, können Sie angeben, welche Schleife ausgeführt werden soll, indem Sie die Schleifennummer an das scenario-Flag übergeben. Hinweis: Wenn Sie den Test lokal ausführen, können Sie jeweils nur eine Schleife ausführen. Wenn Sie beispielsweise Schleifen 1, 2 und 5 ausführen möchten, müssen Sie für jede Schleife einen separaten Befehl ausführen:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=1
xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=2
xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=5

Nächste Schritte

Führen Sie den Test mit der Firebase Console oder der gcloud CLI aus.