Przeprowadź test pętli gry

Automatyzowanie testowania gier może być trudne, jeśli gry mobilne są oparte na różnych Struktura interfejsu. Testy pętli gry umożliwiają integrację testów natywnych Test Lab i łatwo uruchamiaj je na wybranych urządzeniach. Z tego przewodnika dowiesz się, jak przygotować test pętli gry do uruchomienia za pomocą Firebase Test Lab.

Informacje o testach pętli gry

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

1. W Xcode wybierz miejsce docelowe 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 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 uruchamiania testów przy użyciu narzędzia 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 delegacji do aplikacji zastąp metodę application(_:open:options:):

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 <UIApplicationOpenURLOptionsKey, id> *)options {
  if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
      // ...Enter Game Loop Test logic to override application(_:open:options:).
  }
}

Jeśli w teście uruchamiasz kilka pętli, bieżąca pętla jest przekazywana jako parametr do adresu URL używanego do uruchamiania aplikacji. Bieżący numer pętli możesz też uzyskać, analizując obiekt URLComponents, który służy do pobierania niestandardowego schematu URL:

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

Kończenie testu wcześniej

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:

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

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.

Tworzenie niestandardowych wyników testów

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 się do innego miejsca 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.

• Test Lab nie przetwarza wyników testu, dopóki nie zakończą się wszystkie pętle w teście, więc jeśli test zawiera wiele pętli, które zapisują dane wyjściowe, dołącz je do osobnego pliku wyników lub utwórz plik wyników 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];
       }
   }
   

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 na stronie Apple Codesigning

Krok 4. Spakuj aplikację do przesłania

Wygeneruj plik IPA swojej aplikacji (będziesz go później potrzebować).

1. W menu, które się pojawi, kliknij Usługa > Archiwizuj. Wybierz najnowsze archiwum, a następnie kliknij Dystrybucja aplikacji.

2. W wyświetlonym oknie kliknij Programowanie > 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. 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óżna dla każdego projektu). Oczekiwane dane wyjściowe to MyApp.app: valid on disk.

Krok 6. Przeprowadź test lokalnie

Możesz przeprowadzić test lokalnie, aby sprawdzić jego działanie, zanim wykonasz go za pomocą Test Lab Aby przetestować grę lokalnie, wczytaj ją 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ą z nich 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

Dalsze kroki

Uruchom test za pomocą konsoli Firebase lub interfejsu wiersza poleceń gcloud.