Ta strona została przetłumaczona przez Cloud Translation API.

Pierwsze kroki z testami narzędzi

Z tego przewodnika dowiesz się, jak przygotować i przeprowadzić test z instrumentacją, Laboratorium Firebase. Aby skorzystać z tego przewodnika, musisz mieć test instrumentacji (napisanych przez Ciebie lub Twój zespół), która wykorzystuje Espresso lub UI Automator Platformy do testowania Androida. Testy instrumentacji mogą przeprowadzać maksymalnie 45 60 minut na urządzeniach fizycznych i do 60 minut na urządzeniach wirtualnych.

Później musisz przesłać plik APK aplikacji i pliku APK z testu do Firebase.

(Opcjonalnie) Dodawanie biblioteki zrzutów ekranu do aplikacji

Laboratorium Firebase zawiera bibliotekę (testlab-instr-lib), aby przetworzyć zrzuty ekranu zrobione na AndroidzieX. Zrzut ekranu podczas wykonywania testów z instrumentacją, takich jak testy napisane przy użyciu Platforma do testów Espresso. W tej sekcji dowiesz się, jak tworzyć obiekty ScreenCapture za pomocą AndroidaX. i sposobach ich przetwarzania przy użyciu testlab-instr-lib.

Po zakończeniu testu instrumentacji możesz wyświetlić zrzuty ekranu w konsoli Firebase.

Wypróbuj przykładową aplikację

Pobierz przykładową aplikację NotePad. aby wypróbować tę funkcję. Możliwość robienia zrzutów ekranu jest już dostępna włączone do projektu NotePad.

Krok 1. Dodawanie biblioteki zrzutów ekranu do projektu

w pliku Gradle w ustawieniach na poziomie głównym projektu testowego; (settings.gradle.kts lub settings.gradle), dodaj repozytorium Google Maven do każdej sekcji repositories:

pluginManagement {
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
    }
}
// ...

W pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), dodaj zależność dla Biblioteka zrzutów ekranu z Laboratorium.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```

W pliku AndroidManifest.xml testu zarejestruj FirebaseScreenCaptureProcessor w tagu metadanych w tagu <instrumentation>. Możesz też określić procesor jako w AndroidJUnitRunner (zobacz Dokumentacja AndroidJUnitRunner ).

<instrumentation
  // Check that you have the following line (if not, add it):
  android:name="androidx.test.runner.AndroidJUnitRunner" // Specifies AndroidJUnitRunner as the test runner
  android:targetPackage="com.your.package.name">

// Add the following:
<meta-data
  android:name="screenCaptureProcessors"
  android:value="com.google.firebase.testlab.screenshot.FirebaseScreenCaptureProcessor" />
</instrumentation>
...

W pliku AndroidManifest.xml aplikacji dodaj te wiersze w polu Element <manifest>:

 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

W pliku AndroidManifest.xml określ uprawnienia systemowe aplikacji dodając te wiersze w tagu <manifest>. Jeśli testujesz na Androidzie 10 (poziom interfejsu API 29) lub nowszym, pomiń WRITE_EXTERNAL_STORAGE (aplikacja nie wymaga tych uprawnień do odczytywania zapisywanie zrzutów ekranu na urządzeniu).
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

Krok 2. Robienie zrzutów ekranu podczas testu

W dowolnym momencie testu, w którym chcesz zrobić zrzut ekranu, wywołaj Screenshot.capture() z biblioteki AndroidaX. Powoduje to ScreenCapture obiekt. Gdy wywołujesz funkcję process() w obiekcie ScreenCapture, jest ona przetwarzana użycie programu ScreenCaptureProcessor. zarejestrowana w AndroidManifest.xml. Pamiętaj, że parametr Jeśli nie zarejestrowano żadnych procesorów, jest używany interfejs BasicScreenCaptureProcessor. Ponieważ domena FirebaseScreenCaptureProcessor została przez Ciebie zarejestrowana, Twoje zrzuty ekranu zostaną przetworzone za pomocą usługi FirebaseScreenCaptureProcessor i będą dostępne wyniki testu w Laboratorium Firebase.

Przykładowe przypadki użycia funkcji `ScreenCapture`:

Wykonaj pełny zrzut ekranu w kompilacji API.VERSION_CODES.JELLY_BEAN_MR2 i powyżej:
```
Screenshot.capture()
```
Wykonaj ScreenCapture aktywności na dowolnym poziomie interfejsu API. Pamiętaj, że jest to tylko w przypadku urządzeń poniżej kompilacji.VERSION_CODES.JELLY_BEAN_MR2.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

Przykłady użycia zrzutu ekranu

Przetwórz ScreenCapture za pomocą FirebaseScreenCaptureProcessor:
```
Screenshot.capture().process();
```

Przetwarzanie: ScreenCapture za pomocą określonej metody ScreenCaptureProcessor (pozwala to pominąć rejestrację procesora):

Set<ScreenCaptureProcessor> processors = new HashSet<>();
processors.add(new FirebaseScreenCaptureProcessor());
Screenshot.capture().process(processors);

Ustaw nazwę i format obiektu ScreenCapture i przetwórz go za pomocą zarejestrowany podmiot przetwarzający:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

Krok 3. Tworzenie i przeprowadzanie testu

Utwórz aplikację i przetestuj pliki APK (zobacz Testowanie aplikacji ).
Prześlij pliki APK do panelu Laboratorium. w konsoli Firebase.
Na koniec przeprowadź test.

Krok 4. Wyświetlanie testowych zrzutów ekranu

Po zakończeniu testu wszystkie zrzuty ekranu możesz wyświetlić w konsoli Firebase.

Na karcie Testy wybierz ukończony test. Kliknij kartę Wyniki.
Ponownie wybierz test i kliknij kartę Zrzuty ekranu, która się wyświetli.

(Opcjonalnie) Włącz dodatkowe funkcje testowe

Zanim wykonasz test, możesz włączyć w nim te funkcje: Laboratorium:

Włącz narzędzie Symphony

Android Test Assistant, to narzędzie, które niezależnie przeprowadza testy instrumentacji aplikacji. Laboratorium zawsze używa najnowszej wersji narzędzia Artisttor.

Aby włączyć narzędzie Artisttor w Laboratorium, w teście instrumentu kliknij Dodatkowe opcje > Uruchom w narzędziu Artisttor.

Używanie narzędzia Academytor zapewnia następujące korzyści:

Brak udostępnionego stanu. Każdy test działa oddzielnie z instancji instrumentacji, dzięki czemu wspólny stan nie kumuluje się w ramach testów.
Pojedyncze awarie. Jeśli test ulegnie awarii, instrumentacja zostanie zakończona, ale inne testy w pakiecie będą nadal działać.

Pamiętaj, że gdy korzystasz z narzędzia Assistanttor, każdy test uruchamia się w jego ramach. instancję instrumentacji, co oznacza, że proces aplikacji jest uruchamiany ponownie po dla każdego przypadku testowego. Wydłużone czasy trwania mogą mieć wpływ wykorzystaniem limitu lub czasem rozliczania i mogą powoduje przekroczenie limitu limity czasu. Jeśli zmniejszysz czas uruchamiania, narzut się skróci.

Aby ustawić dodatkowe opcje narzędzia Sessiontor, określ je za pomocą: Pole environmentVariables. Aby na przykład użyć atrybutu clearPackageData, użyj tego w gcloud:

--environment-variables clearPackageData=true

Włącz fragmentację

Fragmentacja testowa dzieli zbiór testów na podgrupy (fragmenty), w których działają z osobna. Laboratorium automatycznie uruchamia równolegle każdy fragment na wielu urządzeniach i w krótszym czasie można przeprowadzić cały zestaw testów.

Jeśli na przykład utworzysz N fragmentów, dla każdego wybranego urządzenia Laboratorium uruchomi N na identycznych urządzeniach i na każdym z nich przeprowadzamy podzbiór testów. Oznacza to, że w których przypadku pofragmentowane przypadki testowe mogą powodować wiele wykonań testów na jednym urządzeniu. Przypadki testowe niepodzielone na fragmenty skutkują jednak jednym wykonaniem testu na urządzenia. Aby zapoznać się z założeniami Laboratorium, zobacz artykuł Kluczowe pojęcia.

Aby włączyć fragmentację testową w konsoli Firebase, wykonaj te czynności:

W konfiguracji testu instrumentu kliknij Dodatkowe opcje.
W sekcji Fragmentacja wpisz liczbę fragmentów, które chcesz uruchomić.

Płatności za fragmenty testowe

Laboratorium implementuje fragmenty, wykorzystując wbudowane narzędzie AndroidJUnitRunner oraz mechanizm fragmentacji. Aby uniknąć opłat za utworzenie pustych fragmentów (bez przypisanych fragmentów) przypadków testowych), liczba fragmentów, które powinna być mniejsza od łącznej liczby przypadków testowych. W zależności od sposobu czas potrzebny na przeprowadzenie każdego testu, zwykle dobrze jest przypisać 2–10 testów, przypadków na fragment.

Więcej informacji o rozliczeniach znajdziesz w artykule Wykorzystanie, limity i płatności.