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 je uruchamiać na wybranych urządzeniach. Ten Przewodnik zawiera informacje o tym, jak przygotować test pętli gry do uruchomienia w Laboratorium Firebase.

Informacje o testach pętli gry

Krok 1. Rejestrowanie schematu niestandardowego adresu URL w Laboratorium

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

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

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

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

Krok 3. Podpisz aplikację

1. Upewnij się, że wszystkie artefakty 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 dla aplikacji (będzie trzeba go później znaleźć).

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. Laboratorium 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ą Laboratorium. 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ą 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

Dalsze kroki

Przeprowadź test, korzystając z konsoli Firebase. lub interfejs wiersza poleceń gcloud.