Pierwsze kroki z testami 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. Test pętli gry spowoduje uruchomienie przeprowadzać testy w grze, symulując działania prawdziwego gracza. Ten przewodnik pokazuje, jak uruchomić test pętli gry, a potem wyświetlić go i nim zarządzać w konsoli Firebase.

W zależności od silnika gry możesz wdrażać testy obejmujące jeden lub wiele testów w pętlach filmowych. pętla to pełne lub częściowe omówienie testu; w grze mobilnej. Pętle gry mogą:

  • Poziom gry możesz uruchamiać tak samo jak inne osoby. Dostępne opcje albo skrypt wejściowy użytkownika, pozostawienie użytkownikowi nieaktywności lub zastąpienie elementu użytkownik z AI, jeśli ma to sens w Twojej grze (np.gdy masz samochód wyścigowy). gra mobilna i masz już wdrożoną AI. Możesz łatwo dodać sterownik za odpowiedzi użytkownika).
  • Uruchom grę w najwyższej jakości, aby sprawdzić, czy urządzenia ją obsługują.
  • Przeprowadź test techniczny (skompiluj, uruchom i uruchom wiele programów do cieniowania, sprawdź, czy dane wyjściowe są zgodne z oczekiwaniami itd.).

Test pętli gry możesz przeprowadzić na jednym urządzeniu testowym, grupie urządzeń testowych albo w Test Lab. Nie zalecamy jednak przeprowadzania testów pętli gry na urządzeniach wirtualnych. ponieważ mają mniejszą liczbę klatek na sekundę niż urządzenia fizyczne.

Zanim zaczniesz

Aby wdrożyć test, musisz najpierw skonfigurować aplikację do testów pętli gry.

  1. W manifeście aplikacji dodaj do aktywności nowy filtr intencji:

    <activity android:name=".MyActivity">
   <intent-filter>
       <action android:name="com.google.intent.action.TEST_LOOP"/>
       <category android:name="android.intent.category.DEFAULT"/>
       <data android:mimeType="application/javascript"/>
   </intent-filter>
   <intent-filter>
      ... (other intent filters here)
   </intent-filter>
</activity>

    Dzięki temu Laboratorium może uruchomić grę, włączając ją intencji.

  2. W kodzie (zalecamy to w deklaracji metody onCreate) dodaj :

    Kotlin+KTX 

    val launchIntent = intent
if (launchIntent.action == "com.google.intent.action.TEST_LOOP") {
    val scenario = launchIntent.getIntExtra("scenario", 0)
    // Code to handle your game loop here
}
    MainActivity.kt

    Java 

    Intent launchIntent = getIntent();
if(launchIntent.getAction().equals("com.google.intent.action.TEST_LOOP")) {
    int scenario = launchIntent.getIntExtra("scenario", 0);
    // Code to handle your game loop here
}
    MainActivity.java

    Dzięki temu aktywność może sprawdzać intencje, które ją uruchamiają. Możesz też dodaj ten kod później, jeśli wolisz (np. po pierwszym wczytaniu gry wyszukiwarka).

  3. Zalecane: pod koniec testu dodaj:

    Kotlin+KTX 

    yourActivity.finish()
    MainActivity.kt

    Java 

    yourActivity.finish();
    MainActivity.java

    Spowoduje to zamknięcie aplikacji po zakończeniu testu pętli gry. Działanie testu zależy od tego, od platformy interfejsu aplikacji do rozpoczęcia następnej pętli, o czym informuje jej zamknięcie że test się zakończył.

Utwórz i uruchom test pętli gry

Po skonfigurowaniu aplikacji do testów pętli gry możesz od razu utworzyć przetestować ją i uruchomić w grze mobilnej. Możesz zdecydować się na przeprowadzenie testu w Laboratorium za pomocą konsoli Firebase lub gcloud interfejsu wiersza poleceń (CLI) lub na urządzeniu lokalnym za pomocą pętli testowej Menedżer.

Uruchom na urządzeniu lokalnym

Menedżer pętli testowej dostępny w Laboratorium to aplikacja typu open source, która pomaga integrować testy pętli gry i uruchamiać je na urządzeniach lokalnych. Zapewnia też ds. kontroli jakości w celu uruchomienia tych samych pętli gry na urządzeniach.

Aby uruchomić test na urządzeniu lokalnym za pomocą menedżera pętli testowej:

  1. Pobierz menedżera pętli testowej. na telefonie lub tablecie i zainstaluj je, uruchamiając polecenie: 
    adb install testloopmanager.apk
  2. Na telefonie otwórz aplikację Test Loop Apps (Aplikacje pętli testowej) lub tablecie. Aplikacja wyświetla listę aplikacji na urządzeniu, które można uruchamiać za pomocą pętli gry. Jeśli nie widzisz tutaj swojej gry, upewnij się, filtr intencji pasuje do tego, który jest opisany w pierwszym kroku Zanim zaczniesz:
  3. Wybierz grę, a następnie określ liczbę pętli. Uwaga: w tym kroku możesz uruchomić podzbiór pętli, a nie tylko w jednej pętli. Więcej informacji na temat: Uruchomienie kilku pętli jednocześnie znajdziesz w sekcji Funkcje opcjonalne.
  4. Kliknij Przeprowadź test. Test rozpocznie się od razu.
.

Uruchom w Laboratorium

Test pętli gry możesz przeprowadzić w Laboratorium przy użyciu konsoli Firebase lub gcloud CLI. Przed Tobą w dowolnym momencie, otwórz Konsola Firebase i utwórz projekt.

Korzystanie z konsoli Firebase

  1. W konsoli Firebase kliknij Laboratorium w panelu po lewej stronie.
  2. Kliknij Przeprowadź pierwszy test (lub Przeprowadź test, jeśli projekt ma wcześniej przeprowadzić test).
  3. Jako typ testu wybierz Pętla gry i kliknij Dalej.
  4. Kliknij Przeglądaj, a następnie przejdź do pliku .apk aplikacji. Uwaga: w tym kroku możesz uruchomić podzbiór pętli, a nie tylko w jednej pętli. Więcej informacji na temat: w wielu pętlach jednocześnie, zobacz Funkcje opcjonalne.
  5. Kliknij Dalej.
  6. Wybierz urządzenia fizyczne, których chcesz użyć do testowania aplikacji.
  7. Kliknij Rozpocznij testy.

Więcej informacji o tym, jak zacząć korzystać z konsoli Firebase, znajdziesz w artykule Zacznij testy w konsoli Firebase.

Korzystanie z wiersza poleceń gcloud

  1. Pobierz i zainstaluj pakiet SDK Google Cloud, jeśli jeszcze go nie masz.

  2. Zaloguj się w interfejsie wiersza poleceń gcloud za pomocą konta Google:

    gcloud auth login

  3. Ustaw projekt Firebase w gcloud, gdzie PROJECT_ID to identyfikator projektu Firebase:

    gcloud config set project PROJECT_ID

  4. Przeprowadź pierwszy test:

    gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23

Więcej informacji o tym, jak zacząć korzystać z gcloud CLI, znajdziesz w artykule Testowanie zacznij od wiersza poleceń gcloud.

Funkcje opcjonalne

Laboratorium oferuje kilka opcjonalnych funkcji, które pozwalają Testy, w tym możliwość zapisu danych wyjściowych, obsługa wielu gier i etykiety powiązanych pętli.

Zapisywanie danych wyjściowych

Test pętli gry może zapisać dane wyjściowe w pliku określonym w pliku Metoda launchIntent.getData(). Po przeprowadzeniu testu możesz uzyskać dostęp do tych elementów dane wyjściowe w sekcji Laboratorium konsoli Firebase (zobacz Przykładowy plik wyjściowy pętli gry).

Laboratorium korzysta ze sprawdzonych metod udostępniania pliku między aplikacjami opisanymi tutaj: Udostępnianie pliku W metodzie onCreate() aktywności, w której znajduje się intencja, może sprawdzić plik wyjściowy danych, uruchamiając ten kod:

Kotlin+KTX 

val launchIntent = intent
val logFile = launchIntent.data
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    // ...
}
MainActivity.kt

Java 

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    // ...
}
MainActivity.java

Jeśli chcesz zapisać plik z poziomu języka C++ gry, możesz deskryptora pliku zamiast ścieżki pliku:

Kotlin+KTX 

val launchIntent = intent
val logFile = launchIntent.data
var fd = -1
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    fd = try {
        contentResolver
            .openAssetFileDescriptor(logFile, "w")!!
            .parcelFileDescriptor
            .fd
    } catch (e: FileNotFoundException) {
        e.printStackTrace()
        -1
    } catch (e: NullPointerException) {
        e.printStackTrace()
        -1
    }
}

// C++ code invoked here.
// native_function(fd);
MainActivity.kt

Java 

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
int fd = -1;
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    try {
        fd = getContentResolver()
                .openAssetFileDescriptor(logFile, "w")
                .getParcelFileDescriptor()
                .getFd();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        fd = -1;
    } catch (NullPointerException e) {
        e.printStackTrace();
        fd = -1;
    }
}

// C++ code invoked here.
// native_function(fd);
MainActivity.java

C++

#include <unistd.h>
JNIEXPORT void JNICALL
Java_my_package_name_MyActivity_native_function(JNIEnv *env, jclass type, jint log_file_descriptor) {
// The file descriptor needs to be duplicated.
int my_file_descriptor = dup(log_file_descriptor);
}

Przykład pliku wyjściowego

Aby wyświetlić grę, możesz użyć plików danych wyjściowych (w formacie podanym poniżej) zapętlaj wyniki w sekcji Laboratorium w konsoli Firebase. Obszary wyświetlane jako /.../ mogą zawierać dowolne potrzebne Ci pola niestandardowe, pod warunkiem że nie kolidują z nazwami innych pól użytych w tym pliku:

{
  "name": "test name",
  "start_timestamp": 0, // Timestamp of the test start (in us).
                           Can be absolute or relative
  "driver_info": "...",
  "frame_stats": [
    {
      "timestamp": 1200000, // Timestamp at which this section was written
                               It contains value regarding the period
                               start_timestamp(0) -> this timestamp (1200000 us)
      "avg_frame_time": 15320, // Average time to render a frame in ns
      "nb_swap": 52, // Number of frame rendered
      "threads": [
        {
          "name": "physics",
          "Avg_time": 8030 // Average time spent in this thread per frame in us
        },
        {
          "name": "AI",
          "Avg_time": 2030 // Average time spent in this thread per frame in us
        }
      ],
      /.../ // Any custom field you want (vertices display on the screen, nb units …)
    },
    {
      // Next frame data here, same format as above
    }
  ],
  "loading_stats": [
    {
      "name": "assets_level_1",
      "total_time": 7850, // in us
      /.../
    },
    {
      "name": "victory_screen",
      "total_time": 554, // in us
      /.../
    }

  ],
  /.../, // You can add custom fields here
}

Wiele pętli gry

Warto uruchomić w aplikacji wiele pętli gry. pętla to pełne omówienie aplikacji gry od początku do końca. Jeśli na przykład Jeśli gra ma wiele poziomów, warto dodać jedną pętlę, Uruchamiaj każdy poziom zamiast jednej pętli. Dzięki temu, jeśli aplikacja ulegnie awarii na poziomie 32, możesz od razu ją uruchomić. w pętli umożliwiające odtworzenie awarii i testowanie poprawek błędów.

Aby aplikacja uruchamiała kilka pętli jednocześnie:

  • Jeśli przeprowadzasz test za pomocą menedżera pętli testowej:

    1. Dodaj ten wiersz do pliku manifestu aplikacji, wewnątrz pliku Element <application>: 

      <meta-data
  android:name="com.google.test.loops"
  android:value="5" />

      Ta intencja uruchomienia zawiera pętlę docelową jako parametr liczby całkowitej. W android:value możesz podać liczbę całkowitą od 1 do 1024 maksymalnej dozwolonej liczby pętli w jednym teście). Notatka że pętle są indeksowane od 1, a nie 0.

    2. W aplikacji Menedżer pętli testowej pojawi się ekran wyboru, pozwala wybrać pętle, które chcesz uruchomić. Jeśli wybierzesz kilka opcji każda pętla jest uruchamiana w kolejności po poprzedniej pętli .

  • Jeśli przeprowadzasz test w konsoli Firebase, wpisz listę lub zakresu liczb pętli w polu Scenariusze.

  • Jeśli wykonujesz test za pomocą interfejsu wiersza poleceń gcloud, podaj listę numerów pętli za pomocą flagi --scenario-numbers. Przykład: --scenario-numbers=1,3,5 uruchamia pętle 1, 3 i 5.

  • Jeśli piszesz w C++ i chcesz zmienić działanie pętli, przekaż parametr dodatkowe funkcje do natywnego kodu C++:

    Kotlin+KTX 

    val launchIntent = intent
val scenario = launchIntent.getIntExtra("scenario", 0)
    MainActivity.kt

    Java 

    Intent launchIntent = getIntent();
int scenario = launchIntent.getIntExtra("scenario", 0);
    MainActivity.java

    Możesz teraz zmienić działanie pętli na podstawie wynikowej int .

Oznacz pętle gry

Gdy oznaczysz pętlę gry co najmniej jedną etykietą scenariusza, Ty i Twój zespół kontroli jakości może łatwo uruchomić zestaw powiązanych pętli gry (np. „cała zgodność pętle gry”) i testuj je w ramach jednej macierzy. Możesz tworzyć własne etykiety lub użyj wstępnie zdefiniowanych etykiet oferowanych przez Laboratorium:

  • com.google.test.loops.player_experience: dla pętli używanych do i odtwarzać wrażenia rzeczywistego użytkownika podczas gry. Cel jest wykrywanie problemów, które napotkają prawdziwy użytkownik, grając w grę.
  • com.google.test.loops.gpu_compatibility: na potrzeby pętli używanych do testowania. Problemy z GPU. Testowanie z użyciem tych pętli ma na celu wykonanie GPU który może nie działać prawidłowo w środowisku produkcyjnym, co pozwoliłoby na oraz sterowników.
  • com.google.test.loops.compatibility: w przypadku pętli używanych do testowania szeroki zakres problemów ze zgodnością, w tym problemy I/O i OpenSSL problemów.
  • com.google.test.loops.performance: w przypadku pętli używanych do testowania funkcji wydajność urządzenia. Na przykład gra może działać na najbardziej ustawieniach grafiki, aby sprawdzić, jak działa nowe urządzenie.

Aby umożliwić aplikacji uruchamianie pętli z tą samą etykietą:

  • Jeśli przeprowadzasz test za pomocą menedżera pętli testowej:

    1. W pliku manifestu aplikacji dodaj ten wiersz metadanych i zastąp LABEL_NAME z wybraną przez Ciebie etykietą:

      <meta-data
 android:name="com.google.test.loops.LABEL_NAME"
 android:value="1,3-5" />

      W polu android:value możesz określić zakres lub zbiór liczb całkowitych od 1 do 1024 (maksymalną liczbę pętli dopuszczalnych w jednym teście), która wskazują pętle, które chcesz oznaczyć etykietą. Pamiętaj, że pętle są indeksowane od od 1, a nie od 0. Na przykład zasada android:value="1,3-5" ma zastosowanie LABEL_NAME do pętli 1, 3, 4 i 5.

    2. W aplikacji Menedżer pętli testowej wpisz co najmniej jedną etykietę w polu Etykiety .

  • Jeśli przeprowadzasz test w konsoli Firebase, wpisz co najmniej jedną etykiety w polu Etykiety.

  • Jeśli wykonujesz test za pomocą gcloud CLI, podaj jeden z nich lub dodatkowych etykiet scenariuszy, używając funkcji flaga --scenario-labels (np. --scenario-labels=performance,gpu).

Pomoc dotycząca licencjonowania aplikacji

Laboratorium obsługuje aplikacje, które używają Licencjonowanie aplikacji usłudze oferowanej przez Google Play. Możliwość sprawdzenia licencji podczas testowania aplikację za pomocą Laboratorium, musisz opublikować ją w kanale produkcyjnym w Sklepie Play. Aby przetestować aplikację w kanale alfa lub beta, użyj Laboratorium: przed przesłaniem aplikacji do Laboratorium usuń weryfikację licencjonowania Laboratorium.

Znane problemy

W Laboratorium występują te znane problemy z testami pętli gry:

  • Niektóre awarie nie obsługują ścieżek wstecz. Na przykład niektóre kompilacje wersji mogą blokuj dane wyjściowe procesu debuggerd za pomocą funkcji prctl(PR_SET_DUMPABLE, 0) Więcej informacji: debuggerd.
  • Poziom interfejsu API 19 nie jest obecnie obsługiwany z powodu błędów uprawnień do pliku.