Przeprowadź test pętli gry

Automatyzacja testowania gier może być trudna, gdy aplikacje do gier są tworzone na podstawie różnych frameworków interfejsu użytkownika. Testy Game Loop umożliwiają integrację natywnych testów z Test Lab i łatwe ich uruchamianie na wybranych urządzeniach. Ten Przewodnik zawiera informacje o tym, jak przygotować test pętli gry do uruchomienia za pomocą Firebase Test Lab.

Informacje o testach pętli gry

Co to jest test pętli gry?

Test Game Loop symuluje działania prawdziwego gracza, aby szybko i skalowalnie sprawdzić, czy Twoja gra działa prawidłowo dla użytkowników. pętla to pełne lub częściowe podsumowanie testu na gra mobilna. Test pętli gry możesz przeprowadzić lokalnie w symulatorze lub na zbiorze urządzeń w Test Lab. Testy pętli gry mogą być wykorzystywane do:

  • Przetestuj grę tak, jak robi to użytkownik. Możesz stworzyć skrypt z danymi wejściowymi użytkownika, pozwolić, aby użytkownik był nieaktywny, lub zastąpić go sztuczną inteligencją (na przykład jeśli wdrożyłeś sztuczną inteligencję w grze wyścigowej, możesz ustawić kierowcę AI jako odpowiedzialnego za dane wejściowe użytkownika).
  • Uruchom grę w najwyższej jakości, aby sprawdzić, które urządzenia ją obsługują.
  • Przeprowadź testy techniczne, np. skompiluj i uruchom wiele programów do cieniowania, a potem sprawdź, czy dane wyjściowe będą zgodne z oczekiwaniami.

Krok 1. Zarejestruj niestandardowy schemat adresów URL Test Lab

  1. W Xcode wybierz ustawienie projektu.

  2. Kliknij kartę Informacje i dodaj nowy typ adresu URL.

  3. W polu Schematy adresów URL wpisz firebase-game-loop. Możesz też zarejestrować schemat niestandardowego adresu URL, dodając go do tagu Plik konfiguracji Info.plist w dowolnym miejscu tagu <dict>:

    <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>
    

Aplikacja jest teraz skonfigurowana do przeprowadzania testów za pomocą Test Lab.

Krok 2. Opcjonalnie skonfiguruj aplikację

Uruchom wiele pętli

Jeśli zamierzasz uruchomić w teście wiele pętli (scenariuszy), musisz określić pętle, które mają być uruchomione w aplikacji w momencie jej uruchomienia.

W delegacie aplikacji zastąpij metodę application(_:open:options:):

Swift

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
}

Objective-C

- (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:).
  }
}

Jeśli w teście uruchomisz kilka pętli, bieżąca pętla jest przekazywana jako do adresu URL używanego do uruchamiania aplikacji. Możesz też uzyskać aktualne informacje o przez analizowanie Obiekt URLComponents użyty do pobrania schematu niestandardowego adresu URL:

Swift

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).
}

Objective-C

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).
        }
    }
}

Przerwanie testu

Domyślnie test pętli gry trwa do momentu osiągnięcia limitu czasu. po pięciu minutach, nawet po wykonaniu wszystkich pętli. Gdy po upływie limitu czasu test kończy się i anuluje wszystkie oczekujące pętle. Możesz przyspieszyć test lub zakończyć go wcześniej, wywołując niestandardowy schemat adresu URL Test Lab firebase-game-loop-complete w pliku AppDelegate aplikacji. Przykład:

Swift

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

Objective-C

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

Test pętli gry kończy bieżącą pętlę i wykonuje następną. Gdy nie ma już żadnych pętli do wykonania, test się kończy.

Zapisywanie wyników testów niestandardowych

Możesz skonfigurować test pętli gry tak, aby zapisywał niestandardowe wyniki testu w systemu plików urządzenia. Dzięki temu po uruchomieniu testu Test Lab przechowuje pliki wyników w katalogu GameLoopsResults na potrzeby testów urządzenia (które musisz utworzyć samodzielnie). Po zakończeniu testu Test Lab przenosi wszystkie pliki z katalogu GameLoopResults do zasobnika projektu. Podczas konfigurowania testu pamiętaj o tych kwestiach:

  • Przesyłane są wszystkie pliki wyników wyszukiwania niezależnie od ich typu, rozmiaru czy liczby.

  • Test Lab przetwarza wyniki testu dopiero wtedy, gdy wszystkie pętle w a więc jeśli test zawiera wiele pętli zapisujących dane wyjściowe, pamiętaj, aby dołączyć je do unikalnego pliku wyników lub utworzyć dla każdej pętli. Dzięki temu unikniesz zastępowania wyników z poprzedniej pętli.

Aby skonfigurować test w celu zapisywania niestandardowych wyników testu:

  1. W katalogu Documents aplikacji utwórz katalog o nazwie GameLoopResults.

  2. W dowolnym miejscu w kodzie aplikacji (np. w delegacie aplikacji) dodaj:

    Swift

    /// 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.
      }
    }
    

    Objective-C

    /// 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];
        }
    }
    

Krok 3. Podpisz aplikację

  1. Sprawdź, czy wszystkie elementy w aplikacji są podpisane. Możesz na przykład zrobić to za pomocą Xcode, określając ustawienia podpisywania, takie jak profil obsługi administracyjnej i tożsamość. Więcej informacji znajdziesz w artykule Apple Codesigning.

Krok 4. Nadaj pakietowi aplikację do przesłania

Wygeneruj plik IPA dla aplikacji (będzie trzeba go później znaleźć).

  1. W wyświetlonym menu kliknij Produkt > Archiwizuj. Wybierz najnowsze archiwum i kliknij Rozpowszechnij aplikację.

  2. W wyświetlonym oknie kliknij Rozwój > Dalej.

  3. Opcjonalnie: aby przyspieszyć kompilację, odznacz pole wyboru Odbuduj na podstawie kodu bitowego, a następnie kliknij Dalej. Test Lab nie wymaga zawężania ani ponownego kompilowania aplikacji w celu przeprowadzenia testów bezpiecznie wyłączyć tę opcję.

  4. Kliknij Eksportuj i wpisz katalog, z którego chcesz pobrać plik. do pliku IPA aplikacji.

Krok 5. Sprawdź podpis aplikacji.

  1. Aby zweryfikować podpis aplikacji, rozpakuj plik .ipa, a potem uruchom codesign --verify --deep --verbose /path/to/MyApp.app, gdzie „MyApp” to nazwa aplikacji w rozpakujonym folderze (różni się w zależności od projektu). Oczekiwane dane wyjściowe to MyApp.app: valid on disk.

Krok 6. Przeprowadź test lokalnie

Możesz uruchomić test lokalnie, aby sprawdzić jego działanie, zanim uruchomisz go z użyciem Test Lab. Aby przetestować aplikację lokalnie, wczytaj ją w symulatorze i uruchom:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://
  • UDID symulatora możesz znaleźć, uruchamiając polecenie instruments -s devices.

  • Jeśli działa tylko 1 symulator, zamiast ciągu SIMULATOR_UDID wpisz ciąg specjalny "booted".

Jeśli test zawiera wiele pętli, możesz określić, którą pętlę chcesz uruchomić. przekazując numer pętli do flagi scenario. Pamiętaj, że podczas testowania lokalnie możesz uruchamiać tylko jedną pętlę naraz. Jeśli na przykład chcesz uruchomić pętle 1, 2 i 5, musisz uruchomić osobne polecenie dla każdej z nich:

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

Dalsze kroki

Przeprowadź test za pomocą konsoli Firebase lub interfejs wiersza poleceń gcloud.