Pierwsze kroki z testami pętli gry na iOS

Dzięki testom pętli gry możesz pisać testy natywne dla silnika gry, a następnie uruchamiać je w Laboratorium na wybranych urządzeniach. Dzięki temu nie musisz się martwić. na temat pisania rozwiązań do interfejsu użytkownika lub platform testowania. Test pętli gry symuluje działania prawdziwego gracza, a po uruchomieniu w Laboratorium to szybki i skalowalny sposób na sprawdzenie, czy gra działa dobrze użytkowników.

Na tej stronie dowiesz się, jak uruchomić test pętli gry, a następnie wyświetlić go i nim zarządzać wyświetli się strona Laboratorium w konsoli Firebase. Możesz także dalej dostosować testy za pomocą opcjonalnych funkcji, takich jak pisanie wyników testu niestandardowego lub zakończenie testu wcześniej.

Co to jest test pętli gry?

pętla to pełne lub częściowe podsumowanie testu w grze mobilnej. Dostępne opcje uruchomić test pętli gry lokalnie na symulatorze lub na zbiorze urządzeń Laboratorium. Testy pętli gry mogą być wykorzystywane do:

  • Rozegraj grę tak, jak grałby w nią użytkownik. Dostępne opcje skrypt wprowadzania danych wejściowych użytkownika, pozostawianie użytkownika w stanie bezczynności lub zastąpienie użytkownika. za pomocą AI (jeśli np. masz wdrożone AI w samochodzie wyścigowy, można zastosować kierowcę AI pod kontrolą użytkownika).

  • Uruchom grę w najwyższej jakości, aby dowiedzieć się, na jakich urządzeniach może je obsłużyć.

  • Przeprowadza testy techniczne, np. skompilowanie i uruchomienie wielu cieniowania, i sprawdzić, czy wynik jest zgodny z oczekiwaniami.

Krok 1. Zarejestruj schemat niestandardowego adresu URL Laboratorium

Najpierw musisz zarejestrować w Laboratorium Firebase schemat niestandardowego adresu URL w Twojej aplikacji:

  1. W Xcode wybierz miejsce docelowe 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 w Laboratorium.

Krok 2 (opcjonalny). Skonfiguruj aplikację tak, aby uruchamiała wiele pętli

Jeśli Twoja aplikacja ma zarejestrowanych wiele schematów niestandardowych adresów URL i chcesz ją uruchomić wielu pętli (tzw. scenariusze), musisz określić, która z nich które chcesz uruchomić w aplikacji w chwili wprowadzenia na rynek.

W delegacji do aplikacji zastąp 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).
        }
    }
}

Krok 3. Utwórz i przeprowadź test

Po zarejestrowaniu schematu niestandardowego adresu URL w Laboratorium możesz uruchomić test w konsoli Firebase lub za pomocą interfejsu wiersza poleceń gcloud w wersji beta. W razie potrzeby wygeneruj plik IPA swojej aplikacji aby móc je później znaleźć).

Przeprowadzanie testu w konsoli Firebase

  1. Otwórz konsolę Firebase, jeśli jeszcze jej nie masz. i utwórz projekt.

  2. Na stronie Laboratorium w konsoli Firebase kliknij Uruchom pierwsze Testowanie > Uruchom pętlę gry na iOS.

  3. W sekcji Przesyłanie aplikacji kliknij Przeglądaj, a następnie wybierz plik IPA (jeśli jeszcze nie został wygenerowany, wygeneruj plik IPA); dla Twojej aplikacji).

  4. Opcjonalnie: jeśli chcesz uruchomić wiele pętli (scenariuszy) jednocześnie lub wybierz konkretne pętle do uruchomienia, wpisz ich numery w Scenariuszach. .

    Jeśli na przykład wpiszesz wartości „1–3, 5”, Laboratorium uruchomi pętle 1, 2, 3 i 5. Domyślnie (jeśli nie wprowadzisz niczego w polu Scenariusze): Laboratorium uruchamia tylko pętlę 1.

  5. W sekcji Urządzenia wybierz co najmniej 1 urządzenie fizyczne, które chcesz przetestuj aplikację i kliknij Rozpocznij testy.

Przeprowadzanie testu za pomocą gcloud beta CLI

  1. Skonfiguruj lokalne środowisko pakietu SDK gcloud, a następnie zainstaluj gcloud beta WebView.

  2. Uruchom polecenie gcloud beta firebase test ios run i użyj tego flagi w celu skonfigurowania uruchomienia:

Flagi testów pętli gry
--type

Wymagany: określa typ testu na iOS, który chcesz przeprowadzić. Możesz wpisać typy testowe xctest (domyślny) lub game-loop.

--app

Wymagana: ścieżka bezwzględna (Google Cloud Storage lub systemu plików) do pliku IPA aplikacji. Ta flaga jest ważna tylko wtedy, gdy testów pętli gry.

--scenario-numbers

pętle (inaczej scenariusze), które chcesz uruchomić w swojej aplikacji; Możesz wprowadzić jedną pętlę, listę lub pętlę albo zakres pętli. Domyślna pętla to 1.

Na przykład --scenario-numbers=1-3,5 uruchamia pętle 1, 2, 3 i 5.

--device-model

fizyczne urządzenie, na którym chcesz przeprowadzić test; (sprawdź, które dostępne urządzenia których możesz użyć).

--timeout

Maksymalny czas trwania testu. Możesz wpisać liczbę całkowitą, aby przedstawiają czas trwania w sekundach lub liczbę całkowitą i wyliczenie reprezentujące jako dłuższej jednostki czasu.

Przykład:

  • --timeout=200 wymusza zakończenie testu, gdy osiągnie wartość 200 sek.
  • --timeout=1h wymusza zakończenie testu po upływie maksymalnie godziny.

Na przykład to polecenie uruchamia test pętli gry, który wykonuje pętle 1, 4, 6, 7 i 8 na iPhonie 8 Plus:

gcloud beta firebase test ios run
 --type game-loop --app path/to/my/App.ipa --scenario-numbers 1,4,6-8
 --device-model=iphone8plus

Więcej informacji o gcloud CLI znajdziesz w dokumentacji referencyjnej.

Uruchamianie testu lokalnie

Aby przeprowadzić test lokalnie, wczytaj grę mobilną w symulatorze i uruchom:

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

  • Jeżeli działa tylko jeden symulator, wprowadź specjalny ciąg znaków. "booted" w miejsce 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 możesz uruchamiając test lokalnie tylko w 1 pętli. 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

Wcześniejsze kończenie 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ć rozpocznij test lub zakończ go wcześniej, wywołując schemat niestandardowego adresu URL Laboratorium firebase-game-loop-complete w prośbie AppDelegate Twojej 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 uruchamia następną. Gdy nie ma więcej pętli do uruchomienia, test się kończy.

Zapisz wyniki testu niestandardowego

Możesz skonfigurować test pętli gry tak, aby zapisywał niestandardowe wyniki testu w systemu plików urządzenia. Dzięki temu po uruchomieniu Laboratorium przechowuje pliki wyników w katalogu GameLoopsResults na potrzeby testów urządzenia (które musisz utworzyć samodzielnie). Po zakończeniu testu następuje przejście do Laboratorium. wszystkich plików z katalogu GameLoopResults do zasobnika projektu. Google Keep pamiętaj o następujących kwestiach:

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

  • Laboratorium przetwarza wyniki dopiero wtedy, gdy wszystkie pętle na ścieżce 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. W ten sposób można uniknąć zastępowania wyników poprzedniej pętli.

Aby skonfigurować test i zapisać wyniki testu niestandardowego:

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

  2. W dowolnym miejscu w kodzie aplikacji (np. w przypadku przedstawiciela aplikacji) dodaj parametr :

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