Uruchom test pętli gry

Zautomatyzowanie testowania gier może być trudne, jeśli aplikacje do gier są zbudowane na różnych platformach interfejsu użytkownika. Testy Game Loop pozwalają na integrację testów natywnych z Laboratorium Testowym i łatwe uruchamianie ich na wybranych urządzeniach. W tym przewodniku opisano, jak przygotować test pętli gry do uruchomienia w laboratorium testowym Firebase.

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 dobrze dla użytkowników. Pętla to pełne lub częściowe wykonanie testu w aplikacji do gier. Możesz uruchomić test Game Loop lokalnie na symulatorze lub na zestawie urządzeń w laboratorium testowym. Testy pętli gry można wykorzystać do:

  • Uruchom grę tak, jak zrobiłby to użytkownik końcowy. Możesz albo napisać skrypt wprowadzający dane użytkownika, pozwolić mu być bezczynnym, albo zastąpić go sztuczną inteligencją (na przykład, jeśli zaimplementowałeś sztuczną inteligencję w grze wyścigowej, możesz wyznaczyć sterownik AI odpowiedzialny za wprowadzanie danych przez użytkownika) .
  • Uruchom grę w najwyższych ustawieniach jakości, aby dowiedzieć się, które urządzenia ją obsługują.
  • Uruchom test techniczny, taki jak kompilacja wielu shaderów, wykonanie ich i sprawdzenie, czy dane wyjściowe są zgodne z oczekiwaniami.

Krok 1 : Zarejestruj niestandardowy schemat adresu URL laboratorium testowego

  1. W Xcode wybierz cel projektu.

  2. Kliknij kartę Informacje , a następnie dodaj nowy typ adresu URL .

  3. W polu Schematy adresów URL wpisz firebase-game-loop . Możesz także zarejestrować niestandardowy schemat adresu URL, dodając go do pliku konfiguracyjnego Info.plist projektu w dowolnym miejscu w 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>
    

Twoja aplikacja jest teraz skonfigurowana do przeprowadzania testów w laboratorium testowym.

Krok 2 : Opcjonalnie skonfiguruj swoją aplikację

Uruchom wiele pętli

Jeśli planujesz uruchomić w teście wiele pętli (tzw. scenariuszy), musisz określić, które pętle mają być uruchamiane w aplikacji w momencie uruchamiania.

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

Szybki

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
}

Cel 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 wiele pętli, bieżąca pętla jest przekazywana jako parametr do adresu URL używanego do uruchamiania aplikacji. Możesz także uzyskać numer bieżącej pętli, analizując obiekt URLComponents używany do pobrania niestandardowego schematu adresu URL:

Szybki

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

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

Zakończ test wcześniej

Domyślnie test pętli gry jest kontynuowany aż do osiągnięcia limitu czasu wynoszącego pięć minut, nawet jeśli wszystkie pętle zostały wykonane. Po osiągnięciu 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 laboratorium testowego firebase-game-loop-complete w AppDelegate swojej aplikacji. Na przykład:

Szybki

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

Cel C

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

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

Zapisz niestandardowe wyniki testów

Możesz skonfigurować test Game Loop, aby zapisywał niestandardowe wyniki testu w systemie plików swojego urządzenia. W ten sposób po rozpoczęciu testu Laboratorium Testowe przechowuje pliki wynikowe w katalogu GameLoopsResults na Twoim urządzeniu testowym (który musisz utworzyć samodzielnie). Po zakończeniu testu Laboratorium testowe przenosi wszystkie pliki z katalogu GameLoopResults do zasobnika Twojego projektu. Konfigurując test, pamiętaj o następujących kwestiach:

  • Przesyłane są wszystkie pliki wynikowe niezależnie od typu pliku, rozmiaru i ilości.

  • Laboratorium testowe nie przetwarza wyników testu, dopóki wszystkie pętle w teście nie zostaną uruchomione, więc jeśli test zawiera wiele pętli zapisujących dane wyjściowe, pamiętaj o dołączeniu ich do unikalnego pliku wynikowego lub utworzeniu pliku wynikowego dla każdej pętli. W ten sposób można uniknąć nadpisywania wyników z poprzedniej pętli.

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

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

  2. Z dowolnego miejsca w kodzie aplikacji (np. delegata aplikacji) dodaj następujące elementy:

    Szybki

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

    Cel 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 swoją aplikację

  1. Upewnij się, że wszystkie artefakty w aplikacji są podpisane. Można to na przykład zrobić za pomocą Xcode, określając ustawienia podpisywania, takie jak profil informacyjny i tożsamość. Więcej informacji znajdziesz w artykule: Apple Codesigning

Krok 4 : Spakuj aplikację do przesłania

Wygeneruj plik IPA dla swojej aplikacji (będziesz musiał go później zlokalizować).

  1. W wyświetlonym menu rozwijanym kliknij Produkt > Archiwum . Wybierz najnowsze archiwum, a następnie kliknij opcję Rozpowszechniaj aplikację .

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

  3. Opcjonalnie: Aby uzyskać szybszą kompilację, odznacz opcję Odbuduj z kodu bitowego , a następnie kliknij Dalej . Laboratorium testowe nie wymaga zmniejszania lub przebudowy aplikacji w celu uruchomienia testu, dzięki czemu można bezpiecznie wyłączyć tę opcję.

  4. Kliknij opcję Eksportuj , a następnie wprowadź katalog, do którego chcesz pobrać plik IPA aplikacji.

Krok 5 : Sprawdź podpis aplikacji

  1. Sprawdź podpis aplikacji, rozpakowując plik .ipa, a następnie uruchamiając polecenie codesign --verify --deep --verbose /path/to/MyApp.app gdzie „MojaAplikacja” to nazwa aplikacji w rozpakowanym folderze (różni się w zależności od projektu ). Oczekiwany wynik to MyApp.app: valid on disk .

Krok 6 : Uruchom test lokalnie

Możesz uruchomić test lokalnie, aby sprawdzić jego zachowanie przed uruchomieniem go w laboratorium testowym. Aby przetestować lokalnie, załaduj aplikację do gier w symulatorze i uruchom:

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

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

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 lokalnego uruchamiania testu możesz uruchomić tylko jedną pętlę na raz. Na przykład, jeśli chcesz uruchomić pętle 1, 2 i 5, musisz uruchomić osobne polecenie dla każdej pętli:

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

Następne kroki

Uruchom test, korzystając z konsoli Firebase lub interfejsu wiersza polecenia gcloud .