Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Uji kerangka kerja dan pengujian bawaan di AWS Device Farm
<a name="test-types"></a>

Bagian ini menjelaskan dukungan Device Farm untuk kerangka kerja pengujian dan tipe pengujian bawaan.

Device Farm menjalankan pengujian otomatis dengan mengunggah aplikasi dan pengujian ke bucket Amazon S3 aman yang dikelola oleh layanan. Setelah diunggah, itu memutar infrastruktur yang mendasarinya, termasuk [host pengujian yang dikelola layanan, dan menjalankan pengujian](custom-test-environments-hosts.md) secara paralel pada beberapa perangkat. Hasil pengujian disimpan dalam bucket S3 yang dikelola layanan. Arsitektur ini disebut **eksekusi sisi layanan**, dan merupakan cara cepat dan efisien untuk menjalankan pengujian pada host yang secara fisik dekat dengan perangkat, tanpa perlu mengelola sendiri infrastruktur host pengujian. Pendekatan ini berskala baik untuk pengujian pada banyak perangkat secara independen, serta pengujian dari konteks CI/CD pipa.

Untuk informasi selengkapnya tentang cara Device Farm menjalankan pengujian, lihat[Uji lingkungan di AWS Device Farm](test-environments.md).

**catatan**  
Untuk penguji Appium, Anda mungkin lebih suka menjalankan tes Appium dari lingkungan lokal Anda. Dengan [sesi akses jarak jauh](remote-access.md), Anda dapat menjalankan pengujian **Appium sisi klien**. Untuk informasi lebih lanjut, silakan lihat pengujian [Appium sisi klien](appium-endpoint.md).

## Kerangka pengujian
<a name="test-types-framework"></a>

Device Farm mendukung kerangka kerja pengujian otomatisasi seluler ini:

### Kerangka kerja pengujian aplikasi Android
<a name="test-types-framework-android-list"></a>
+ [Tes Appium otomatisMengintegrasikan dengan tes Appium](test-types-appium.md)
+ [Instrumentasi](test-types-android-instrumentation.md)

### Kerangka kerja pengujian aplikasi iOS
<a name="test-types-framework-ios-list"></a>
+ [Tes Appium otomatisMengintegrasikan dengan tes Appium](test-types-appium.md)
+ [XCTest](test-types-ios-xctest.md)
+ [XCTest UI](test-types-ios-xctest-ui.md)

### Kerangka kerja pengujian aplikasi web
<a name="test-types-framework-web-app-list"></a>

Aplikasi web didukung menggunakan Appium. Untuk informasi lebih lanjut tentang membawa tes Anda ke Appium, lihat. [Jalankan pengujian Appium secara otomatis di Device FarmMengintegrasikan tes Appium dengan Device Farm](test-types-appium.md)

### Kerangka kerja di lingkungan pengujian khusus
<a name="test-types-framework-custom-support"></a>

Device Farm tidak memberikan dukungan untuk menyesuaikan lingkungan pengujian untuk XCTest kerangka kerja. Untuk informasi selengkapnya, lihat [Lingkungan pengujian khusus di AWS Device Farm](custom-test-environments.md).

### Dukungan versi Appium
<a name="test-types-framework-appium"></a>

Untuk pengujian yang berjalan di lingkungan khusus, Device Farm mendukung Appium versi 1. Untuk informasi selengkapnya, lihat [Uji lingkungan di AWS Device Farm](test-environments.md).

## Jenis pengujian bawaan
<a name="test-types-built-in"></a>

Dengan pengujian bawaan, Anda dapat menguji aplikasi di beberapa perangkat tanpa harus menulis dan memelihara skrip otomatisasi pengujian. Device Farm menawarkan satu jenis pengujian bawaan:
+ [Bawaan: fuzz (Android dan iOS)](test-types-built-in-fuzz.md)

# Jalankan pengujian Appium secara otomatis di Device Farm
<a name="test-types-appium"></a><a name="test-types-ios-appium-java-testng"></a><a name="test-types-ios-appium-java-junit"></a><a name="test-types-ios-appium-python"></a><a name="test-types-ios-appium-ruby"></a><a name="test-types-ios-appium-node"></a><a name="test-types-android-appium-java-testng"></a><a name="test-types-android-appium-java-junit"></a><a name="test-types-android-appium-python"></a><a name="test-types-android-appium-ruby"></a><a name="test-types-android-appium-node"></a><a name="test-types-web-app-appium-java-testng"></a><a name="test-types-web-app-appium-java-junit"></a><a name="test-types-web-app-appium-python"></a><a name="test-types-web-app-appium-ruby"></a><a name="test-types-web-app-appium-node"></a>

**catatan**  
Halaman ini mencakup menjalankan pengujian Appium di lingkungan eksekusi sisi **server** terkelola Device Farm. [Untuk menjalankan pengujian Appium dari lingkungan **sisi klien** lokal Anda selama sesi akses jarak jauh, lihat pengujian Appium sisi klien.](appium-endpoint.md)

Bagian ini menjelaskan cara mengonfigurasi, mengemas, dan mengunggah pengujian Appium agar berjalan di lingkungan sisi server terkelola Device Farm. Appium adalah alat open source untuk mengotomatiskan aplikasi web asli dan seluler. Untuk informasi lebih lanjut, lihat [Pengantar Appium](http://appium.io/docs/en/latest/intro) di situs web Appium.

Untuk contoh aplikasi dan tautan ke pengujian yang berfungsi, lihat [Aplikasi Sampel Device Farm untuk Android dan Aplikasi](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) [Sampel Device Farm untuk iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) aktif GitHub.

Untuk informasi selengkapnya tentang pengujian di Device Farm dan cara kerja sisi server, lihat. [Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md)

## Memilih versi Appium
<a name="w2aac24c15c41"></a>

**catatan**  
 Support untuk versi Appium tertentu, driver Appium, atau pemrograman SDKs akan bergantung pada perangkat dan host uji yang dipilih untuk uji coba. 

 Host pengujian Device Farm telah diinstal sebelumnya dengan Appium untuk mengaktifkan penyiapan pengujian yang lebih cepat untuk kasus penggunaan yang lebih mudah. Namun, penggunaan file spesifikasi pengujian memungkinkan Anda menginstal versi Appium yang berbeda jika diperlukan. 

### Skenario 1: Versi Appium yang telah dikonfigurasi sebelumnya
<a name="w2aac24c15c41b7b1"></a>

 Device Farm hadir pra-konfigurasi dengan versi server Appium yang berbeda berdasarkan host uji. Host dilengkapi dengan perkakas yang memungkinkan versi pra-konfigurasi dengan driver default platform perangkat (UiAutomator2 untuk Android, dan untuk XCUITest iOS). 

```
phases:
  install:
    commands:
      - export APPIUM_VERSION=2
      - devicefarm-cli use appium $APPIUM_VERSION
```

 Untuk melihat daftar perangkat lunak yang didukung, lihat topik di[Perangkat lunak yang didukung dalam lingkungan pengujian khusus](custom-test-environments-hosts-software.md). 

### Skenario 2: Versi Appium Kustom
<a name="w2aac24c15c41b7b3"></a>

 Untuk memilih versi kustom Appium, gunakan `npm` perintah untuk menginstalnya. Contoh berikut menunjukkan cara menginstal versi terbaru Appium 2. 

```
phases:
  install:
    commands:
      - export APPIUM_VERSION=2
      - npm install -g appium@$APPIUM_VERSION
```

### Skenario 3: Appium di host iOS Legacy
<a name="w2aac24c15c41b7b5"></a>

 Pada[Host uji iOS lama](custom-test-environments-hosts-ios.md#legacy-ios-host), Anda dapat memilih versi Appium tertentu dengan. `avm` Misalnya, untuk menggunakan `avm` perintah untuk menyetel versi server Appium`2.1.2`, tambahkan perintah ini ke file YAMM spesifikasi pengujian Anda. 

```
phases:
  install:
    commands:
      - export APPIUM_VERSION=2.1.2
      - avm $APPIUM_VERSION
```

## Memilih WebDriverAgent versi untuk pengujian iOS
<a name="test-types-appium-select-wda"></a>

 Untuk menjalankan tes Appium pada perangkat iOS, penggunaan WebDriverAgent diperlukan. Aplikasi ini harus ditandatangani agar dapat diinstal pada perangkat iOS. Device Farm menyediakan versi yang telah ditandatangani sebelumnya WebDriverAgent yang tersedia selama lingkungan pengujian kustom dijalankan. 

 Cuplikan kode berikut dapat digunakan untuk memilih WebDriverAgent versi di Device Farm dalam file spesifikasi pengujian Anda yang kompatibel dengan versi Driver XCTest UI Anda.. 

```
phases:
  pre_test:
    commands:
      - |-
        APPIUM_DRIVER_VERSION=$(appium driver list --installed --json | jq -r ".xcuitest.version" | cut -d "." -f 1);
        CORRESPONDING_APPIUM_WDA=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V${APPIUM_DRIVER_VERSION}")
        if [[ ! -z "$APPIUM_DRIVER_VERSION" ]] && [[ ! -z "$CORRESPONDING_APPIUM_WDA" ]]; then
          echo "Using Device Farm's prebuilt WDA version ${APPIUM_DRIVER_VERSION}.x, which corresponds with your driver";
          DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $CORRESPONDING_APPIUM_WDA | cut -d "=" -f2)
        else
          LATEST_SUPPORTED_WDA_VERSION=$(env | grep "DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH_V" | sort -V -r | head -n 1)
          echo "Unknown driver version $APPIUM_DRIVER_VERSION; falling back to the Device Farm default version of $LATEST_SUPPORTED_WDA_VERSION";
          DEVICEFARM_APPIUM_WDA_DERIVED_DATA_PATH=$(echo $LATEST_SUPPORTED_WDA_VERSION | cut -d "=" -f2)
        fi;
```

 [Untuk informasi selengkapnya tentang WebDriverAgent, lihat dokumentasi Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) 

# Mengintegrasikan tes Appium dengan Device Farm
<a name="test-types-appium-integrate"></a>

Gunakan petunjuk berikut untuk mengintegrasikan pengujian Appium dengan AWS Device Farm. Untuk informasi selengkapnya tentang menggunakan pengujian Appium di Device Farm, lihat. [Jalankan pengujian Appium secara otomatis di Device FarmMengintegrasikan tes Appium dengan Device Farm](test-types-appium.md)

## Konfigurasikan paket uji Appium Anda
<a name="test-types-appium-prepare"></a>

Gunakan petunjuk berikut untuk mengonfigurasi paket pengujian Anda.

------
#### [ Java (JUnit) ]

1. Ubah `pom.xml` untuk mengatur kemasan ke file JAR:

   ```
   <groupId>com.acme</groupId>
   <artifactId>acme-myApp-appium</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   ```

1. Ubah `pom.xml` `maven-jar-plugin` untuk digunakan untuk membangun pengujian Anda menjadi file JAR.

   Plugin berikut membangun kode sumber pengujian Anda (apa pun di `src/test` direktori) ke dalam file JAR:

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <executions>
       <execution>
         <goals>
           <goal>test-jar</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   ```

1. Ubah `pom.xml` untuk digunakan `maven-dependency-plugin` untuk membangun dependensi sebagai file JAR.

   Plugin berikut menyalin dependensi Anda ke direktori: `dependency-jars` 

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <version>2.10</version>
     <executions>
       <execution>
         <id>copy-dependencies</id>
         <phase>package</phase>
         <goals>
           <goal>copy-dependencies</goal>
         </goals>
         <configuration>
           <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

1. Simpan rakitan XHTML berikut ke`src/main/assembly/zip.xml`.

   XHTML berikut adalah definisi perakitan yang, ketika dikonfigurasi, menginstruksikan Maven untuk membuat file.zip yang berisi segala sesuatu di root direktori keluaran build Anda dan direktori: `dependency-jars` 

   ```
   <assembly
       xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
     <id>zip</id>
     <formats>
       <format>zip</format>
     </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
     <fileSets>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>*.jar</include>
         </includes>
       </fileSet>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>/dependency-jars/</include>
         </includes>
       </fileSet>
     </fileSets>
   </assembly>
   ```

1. Ubah `pom.xml` untuk digunakan `maven-assembly-plugin` untuk mengemas tes dan semua dependensi menjadi satu file.zip.

   Plugin berikut menggunakan rakitan sebelumnya untuk membuat file.zip bernama `zip-with-dependencies` di direktori keluaran build setiap kali **mvn package** dijalankan: 

   ```
   <plugin>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.4</version>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>single</goal>
         </goals>
         <configuration>
           <finalName>zip-with-dependencies</finalName>
           <appendAssemblyId>false</appendAssemblyId>
           <descriptors>
             <descriptor>src/main/assembly/zip.xml</descriptor>
           </descriptors>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

**catatan**  
Jika Anda menerima kesalahan yang mengatakan anotasi tidak didukung di 1.3, tambahkan yang berikut ini ke`pom.xml`:  

```
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>
```

------
#### [ Java (TestNG) ]

1. Ubah `pom.xml` untuk mengatur kemasan ke file JAR:

   ```
   <groupId>com.acme</groupId>
   <artifactId>acme-myApp-appium</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   ```

1. Ubah `pom.xml` `maven-jar-plugin` untuk digunakan untuk membangun pengujian Anda menjadi file JAR.

   Plugin berikut membangun kode sumber pengujian Anda (apa pun di `src/test` direktori) ke dalam file JAR:

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-jar-plugin</artifactId>
     <version>2.6</version>
     <executions>
       <execution>
         <goals>
           <goal>test-jar</goal>
         </goals>
       </execution>
     </executions>
   </plugin>
   ```

1. Ubah `pom.xml` untuk digunakan `maven-dependency-plugin` untuk membangun dependensi sebagai file JAR.

   Plugin berikut menyalin dependensi Anda ke direktori: `dependency-jars` 

   ```
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <version>2.10</version>
     <executions>
       <execution>
         <id>copy-dependencies</id>
         <phase>package</phase>
         <goals>
           <goal>copy-dependencies</goal>
         </goals>
         <configuration>
           <outputDirectory>${project.build.directory}/dependency-jars/</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

1. Simpan rakitan XHTML berikut ke`src/main/assembly/zip.xml`.

   XHTML berikut adalah definisi perakitan yang, ketika dikonfigurasi, menginstruksikan Maven untuk membuat file.zip yang berisi segala sesuatu di root direktori keluaran build Anda dan direktori: `dependency-jars` 

   ```
   <assembly
       xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
     <id>zip</id>
     <formats>
       <format>zip</format>
     </formats>
     <includeBaseDirectory>false</includeBaseDirectory>
     <fileSets>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>*.jar</include>
         </includes>
       </fileSet>
       <fileSet>
         <directory>${project.build.directory}</directory>
         <outputDirectory>./</outputDirectory>
         <includes>
           <include>/dependency-jars/</include>
         </includes>
       </fileSet>
     </fileSets>
   </assembly>
   ```

1. Ubah `pom.xml` untuk digunakan `maven-assembly-plugin` untuk mengemas tes dan semua dependensi menjadi satu file.zip.

   Plugin berikut menggunakan rakitan sebelumnya untuk membuat file.zip bernama `zip-with-dependencies` di direktori keluaran build setiap kali **mvn package** dijalankan: 

   ```
   <plugin>
     <artifactId>maven-assembly-plugin</artifactId>
     <version>2.5.4</version>
     <executions>
       <execution>
         <phase>package</phase>
         <goals>
           <goal>single</goal>
         </goals>
         <configuration>
           <finalName>zip-with-dependencies</finalName>
           <appendAssemblyId>false</appendAssemblyId>
           <descriptors>
             <descriptor>src/main/assembly/zip.xml</descriptor>
           </descriptors>
         </configuration>
       </execution>
     </executions>
   </plugin>
   ```

**catatan**  
Jika Anda menerima kesalahan yang mengatakan anotasi tidak didukung di 1.3, tambahkan yang berikut ini ke`pom.xml`:  

```
<plugin>
  <artifactId>maven-compiler-plugin</artifactId>
  <configuration>
    <source>1.7</source>
    <target>1.7</target>
  </configuration>
</plugin>
```

------
#### [ Node.JS ]

Untuk mengemas pengujian Appium Node.js dan mengunggahnya ke Device Farm, Anda harus menginstal yang berikut ini di mesin lokal Anda:
+ [Manajer Versi Node (nvm)](https://github.com/nvm-sh/nvm) 

  Gunakan alat ini saat Anda mengembangkan dan mengemas pengujian Anda sehingga dependensi yang tidak perlu tidak disertakan dalam paket pengujian Anda.
+ Node.js
+ npm-bundle (diinstal secara global)

1. Verifikasi bahwa nvm ada

   ```
   command -v nvm
   ```

   Anda harus melihat `nvm` sebagai output.

   Untuk informasi lebih lanjut, lihat [nvm](https://github.com/nvm-sh/nvm) di. GitHub

1. Jalankan perintah ini untuk menginstal Node.js:

   ```
   nvm install node
   ```

   Anda dapat menentukan versi tertentu dari Node.js:

   ```
   nvm install 11.4.0
   ```

1. Verifikasi bahwa versi Node yang benar sedang digunakan:

   ```
   node -v
   ```

1. Instal **npm-bundle** secara global:

   ```
   npm install -g npm-bundle
   ```

------
#### [ Python ]

1. Kami sangat menyarankan Anda menyiapkan [virtualenv Python](https://pypi.python.org/pypi/virtualenv) untuk mengembangkan dan mengemas pengujian sehingga dependensi yang tidak perlu tidak disertakan dalam paket aplikasi Anda.

   ```
   $ virtualenv workspace
   $ cd workspace
   $ source bin/activate
   ```
**Tip**  
Jangan membuat virtualenv Python dengan `--system-site-packages` opsi, karena itu mewarisi paket dari direktori paket situs global Anda. Ini dapat mengakibatkan termasuk dependensi di lingkungan virtual Anda yang tidak diperlukan oleh pengujian Anda.
Anda juga harus memverifikasi bahwa pengujian Anda tidak menggunakan dependensi yang bergantung pada pustaka asli, karena pustaka asli ini mungkin tidak ada pada instance tempat pengujian ini dijalankan.

1. Instal **py.test** di lingkungan virtual Anda.

   ```
   $ pip install pytest
   ```

1. Instal klien Appium Python di lingkungan virtual Anda.

   ```
   $ pip install Appium-Python-Client
   ```

1. Kecuali Anda menentukan jalur yang berbeda dalam mode kustom, Device Farm mengharapkan pengujian Anda disimpan`tests/`. Anda dapat menggunakan `find` untuk menampilkan semua file di dalam folder:

   ```
   $ find tests/
   ```

   Konfirmasikan bahwa file-file ini berisi rangkaian pengujian yang ingin Anda jalankan di Device Farm

   ```
   tests/
   tests/my-first-tests.py
   tests/my-second-tests/py
   ```

1. Jalankan perintah ini dari folder ruang kerja lingkungan virtual Anda untuk menampilkan daftar pengujian Anda tanpa menjalankannya.

   ```
   $ py.test --collect-only tests/
   ```

   Konfirmasikan bahwa output menunjukkan pengujian yang ingin Anda jalankan di Device Farm.

1. Bersihkan semua file yang di-cache di bawah folder tests/Anda:

   ```
   $ find . -name '__pycache__' -type d -exec rm -r {} +
   $ find . -name '*.pyc' -exec rm -f {} +
   $ find . -name '*.pyo' -exec rm -f {} +
   $ find . -name '*~' -exec rm -f {} +
   ```

1. Jalankan perintah berikut di ruang kerja Anda untuk menghasilkan file requirements.txt:

   ```
   $ pip freeze > requirements.txt
   ```

------
#### [ Ruby ]

Untuk mengemas tes Appium Ruby Anda dan mengunggahnya ke Device Farm, Anda harus menginstal yang berikut ini di mesin lokal Anda:
+ [Manajer Versi Ruby (RVM)](https://rvm.io/rvm/install)

  Gunakan alat baris perintah ini saat Anda mengembangkan dan mengemas pengujian Anda sehingga dependensi yang tidak perlu tidak disertakan dalam paket pengujian Anda. 
+ Ruby
+ Bundler (Permata ini biasanya dipasang dengan Ruby.)

1. Instal kunci yang diperlukan, RVM, dan Ruby. Untuk petunjuk, lihat [Menginstal RVM di situs web](https://rvm.io/rvm/install) RVM.

   Setelah instalasi selesai, muat ulang terminal Anda dengan keluar dan kemudian masuk lagi.
**catatan**  
RVM dimuat sebagai fungsi untuk shell bash saja.

1. Verifikasi bahwa **rvm** sudah terpasang dengan benar

   ```
   command -v rvm
   ```

   Anda harus melihat `rvm` sebagai output.

1. Jika Anda ingin menginstal versi Ruby tertentu, seperti*2.5.3*, jalankan perintah berikut:

   ```
   rvm install ruby 2.5.3 --autolibs=0
   ```

   Verifikasi bahwa Anda menggunakan versi Ruby yang diminta:

   ```
   ruby -v
   ```

1. Konfigurasikan bundler untuk mengkompilasi paket untuk platform pengujian yang Anda inginkan:

   ```
   bundle config specific_platform true
   ```

1. Perbarui file.lock Anda untuk menambahkan platform yang diperlukan untuk menjalankan pengujian.
   + Jika Anda mengompilasi pengujian untuk dijalankan di perangkat Android, jalankan perintah ini untuk mengonfigurasi Gemfile agar menggunakan dependensi untuk host pengujian Android:

     ```
     bundle lock --add-platform x86_64-linux
     ```
   + Jika Anda mengompilasi pengujian untuk dijalankan di perangkat iOS, jalankan perintah ini untuk mengonfigurasi Gemfile agar menggunakan dependensi untuk host uji iOS:

     ```
     bundle lock --add-platform x86_64-darwin
     ```

1. **bundler**Permata biasanya dipasang secara default. Jika tidak, instal:

   ```
   gem install bundler -v 2.3.26
   ```

------

## Buat file paket uji zip
<a name="test-types-appium-create-a-zip"></a>

**Awas**  
Di Device Farm, struktur folder file dalam paket pengujian zip Anda penting, dan beberapa alat arsip akan mengubah struktur file ZIP Anda secara implisit. Kami menyarankan Anda mengikuti utilitas baris perintah yang ditentukan di bawah ini daripada menggunakan utilitas arsip yang dibangun ke dalam pengelola file desktop lokal Anda (seperti Finder atau Windows Explorer).

Sekarang, bundel pengujian Anda untuk Device Farm.

------
#### [ Java (JUnit) ]

Bangun dan kemas pengujian Anda:

```
$ mvn clean package -DskipTests=true
```

File `zip-with-dependencies.zip` akan dibuat sebagai hasilnya. Ini adalah paket tes Anda.

------
#### [ Java (TestNG) ]

Bangun dan kemas pengujian Anda:

```
$ mvn clean package -DskipTests=true
```

File `zip-with-dependencies.zip` akan dibuat sebagai hasilnya. Ini adalah paket tes Anda.

------
#### [ Node.JS ]

1. Periksa proyek Anda.

   Pastikan Anda berada di direktori root proyek Anda. Anda dapat `package.json` melihat di direktori root.

1. Jalankan perintah ini untuk menginstal dependensi lokal Anda.

   ```
   npm install
   ```

   Perintah ini juga membuat `node_modules` folder di dalam direktori Anda saat ini.
**catatan**  
Pada titik ini, Anda harus dapat menjalankan pengujian Anda secara lokal.

1. Jalankan perintah ini untuk mengemas file di folder Anda saat ini ke dalam file\$1.tgz. File diberi nama menggunakan `name` properti di `package.json` file Anda.

   ```
   npm-bundle
   ```

   File tarball (.tgz) ini berisi semua kode dan dependensi Anda.

1. Jalankan perintah ini untuk menggabungkan tarball (\$1.tgz file) yang dihasilkan pada langkah sebelumnya ke dalam satu arsip zip:

   ```
   zip -r MyTests.zip *.tgz
   ```

   Ini adalah `MyTests.zip` file yang Anda unggah ke Device Farm dalam prosedur berikut.

------
#### [ Python ]

Python 2  
Buat arsip paket Python yang diperlukan (disebut “wheelhouse”) menggunakan pip:  

```
$ pip wheel --wheel-dir wheelhouse -r requirements.txt
```
Package ruang kemudi, pengujian, dan persyaratan pip Anda ke dalam arsip zip untuk Device Farm:  

```
$ zip -r test_bundle.zip tests/ wheelhouse/ requirements.txt
```

Python 3  
Package tes dan persyaratan pip Anda ke dalam file zip:  

```
$ zip -r test_bundle.zip tests/ requirements.txt
```

------
#### [ Ruby ]

1. Jalankan perintah ini untuk membuat lingkungan Ruby virtual:

   ```
   # myGemset is the name of your virtual Ruby environment
   rvm gemset create myGemset
   ```

1. Jalankan perintah ini untuk menggunakan lingkungan yang baru saja Anda buat:

   ```
   rvm gemset use myGemset
   ```

1. Periksa kode sumber Anda.

   Pastikan Anda berada di direktori root proyek Anda. Anda dapat `Gemfile` melihat di direktori root.

1. Jalankan perintah ini untuk menginstal dependensi lokal Anda dan semua permata dari: `Gemfile`

   ```
   bundle install
   ```
**catatan**  
Pada titik ini, Anda harus dapat menjalankan pengujian Anda secara lokal. Gunakan perintah ini untuk menjalankan pengujian secara lokal:  

   ```
   bundle exec $test_command
   ```

1. Package permata Anda di `vendor/cache` folder.

   ```
   # This will copy all the .gem files needed to run your tests into the vendor/cache directory
   bundle package --all-platforms
   ```

1. Jalankan perintah berikut untuk menggabungkan kode sumber Anda, bersama dengan semua dependensi Anda, ke dalam satu arsip zip:

   ```
   zip -r MyTests.zip Gemfile vendor/ $(any other source code directory files)
   ```

   Ini adalah `MyTests.zip` file yang Anda unggah ke Device Farm dalam prosedur berikut.

------

## Unggah paket pengujian Anda ke Device Farm
<a name="test-types-appium-upload"></a>

Anda dapat menggunakan konsol Device Farm untuk mengunggah pengujian.

1. Masuk ke konsol Device Farm di [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).

1. Pada panel navigasi Device Farm, pilih **Pengujian Perangkat Seluler**, lalu pilih **Proyek**.

1. Jika Anda adalah pengguna baru, pilih **Proyek baru**, masukkan nama untuk proyek, lalu pilih **Kirim**.

   Jika Anda sudah memiliki proyek, Anda dapat memilihnya untuk mengunggah tes Anda ke sana.

1. Buka proyek Anda, lalu pilih **Create run**.

1. Di bawah **pengaturan Jalankan**, berikan nama yang sesuai pada pengujian Anda. Ini mungkin berisi kombinasi spasi atau tanda baca.

1.   
Untuk pengujian Android dan iOS asli  
Di bawah **Pengaturan Jalankan**, pilih **aplikasi Android** jika Anda menguji aplikasi Android (.apk), atau pilih **aplikasi iOS** jika Anda menguji aplikasi iOS (.ipa). Kemudian, di bawah **Pilih aplikasi**, pilih **Unggah aplikasi sendiri** untuk mengunggah paket yang dapat didistribusikan aplikasi Anda.  
 File harus berupa Android `.apk` atau iOS`.ipa`. Aplikasi iOS harus dibangun untuk perangkat nyata, bukan Simulator.   
Untuk pengujian aplikasi Web Seluler  
Di bawah **Setelan Jalankan**, pilih **Aplikasi Web**.

1. Di bawah **Configure test**, di bagian **Select test framework**, pilih framework Appium yang Anda uji, lalu **Upload paket pengujian Anda sendiri**.

1. Jelajahi dan pilih file.zip yang berisi pengujian Anda. File.zip harus mengikuti format yang dijelaskan dalam[Konfigurasikan paket uji Appium Anda](#test-types-appium-prepare).

1. Ikuti petunjuk untuk memilih perangkat dan mulai menjalankan. Untuk informasi selengkapnya, lihat [Membuat uji coba di Device Farm](how-to-create-test-run.md).

**catatan**  
Device Farm tidak mengubah pengujian Appium.

## Ambil tangkapan layar pengujian Anda (Opsional)
<a name="test-types-appium-screenshots"></a>

Anda dapat mengambil tangkapan layar sebagai bagian dari pengujian Anda.

Device Farm menyetel `DEVICEFARM_SCREENSHOT_PATH` properti ke jalur yang sepenuhnya memenuhi syarat pada sistem file lokal tempat Device Farm mengharapkan tangkapan layar Appium disimpan. Direktori khusus uji tempat tangkapan layar disimpan ditentukan saat runtime. Tangkapan layar ditarik ke laporan Device Farm Anda secara otomatis. Untuk melihat tangkapan layar, di konsol Device Farm, pilih bagian **Screenshots**.

 Untuk informasi selengkapnya tentang pengambilan tangkapan layar dalam pengujian Appium, lihat [Mengambil Screenshot di dokumentasi](http://appium.io/docs/en/commands/session/screenshot/) Appium API. 

# Pengujian Android di AWS Device Farm
<a name="test-types-android-tests"></a>

Device Farm menyediakan dukungan untuk beberapa jenis pengujian otomatisasi untuk perangkat Android, dan dua pengujian bawaan. 

Untuk informasi selengkapnya tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

## Kerangka kerja pengujian aplikasi Android
<a name="test-types-framework-android"></a>

Tes berikut tersedia untuk perangkat Android.
+ [Tes Appium otomatisMengintegrasikan dengan tes Appium](test-types-appium.md)
+ [Instrumentasi](test-types-android-instrumentation.md)

## Jenis pengujian bawaan untuk Android
<a name="test-types-built-in-android"></a>

Ada satu jenis pengujian bawaan yang tersedia untuk perangkat Android:
+ [Bawaan: fuzz (Android dan iOS)](test-types-built-in-fuzz.md)

# Instrumentasi untuk Android dan AWS Device Farm
<a name="test-types-android-instrumentation"></a>

Device Farm menyediakan dukungan untuk Instrumentasi (JUnit, Espresso, Robotium, atau pengujian berbasis Instrumentasi) untuk Android.

Device Farm juga menyediakan contoh aplikasi Android dan tautan ke pengujian yang berfungsi di tiga kerangka kerja otomatisasi Android, termasuk Instrumentation (Espresso). [Aplikasi contoh Device Farm untuk Android](https://github.com/awslabs/aws-device-farm-sample-app-for-android) tersedia untuk diunduh GitHub.

Untuk informasi selengkapnya tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

**Topics**
+ [Apa itu instrumentasi?](#test-types-android-instrumentation-what-is)
+ [Pertimbangan untuk pengujian instrumentasi Android](#test-types-android-instrumentation-settings)
+ [Penguraian uji mode standar](#test-types-android-standard-mode-test-parse)
+ [Mengintegrasikan Instrumentasi Android dengan Device Farm](test-types-android-instrumentation-integrate.md)

## Apa itu instrumentasi?
<a name="test-types-android-instrumentation-what-is"></a>

Instrumentasi Android memungkinkan Anda untuk memanggil metode callback dalam kode pengujian sehingga Anda dapat menjalankan siklus hidup komponen selangkah demi selangkah, seolah-olah Anda sedang men-debug komponen. Untuk informasi selengkapnya, lihat [Pengujian instrumen](https://developer.android.com/studio/test/test-in-android-studio#test_types_and_locations) di bagian *Jenis dan lokasi pengujian* pada dokumentasi *Alat Developer Android*.

## Pertimbangan untuk pengujian instrumentasi Android
<a name="test-types-android-instrumentation-settings"></a>

Saat menggunakan instrumentasi Android, pertimbangkan rekomendasi dan catatan berikut.

**Periksa Kompatibilitas OS Android**  
 Periksa [dokumentasi Android](https://developer.android.com/jetpack/androidx/releases/test#orchestrator-1.5.0), untuk memastikan Instrumentasi kompatibel dengan versi OS Android Anda. 

**Berjalan dari Command Line**  
 Untuk menjalankan pengujian Instrumentasi dari baris perintah, ikuti [dokumentasi Android](https://developer.android.com/training/testing/instrumented-tests/androidx-test-libraries/runner#enable-command). 

**Animasi Sistem**  
 Sesuai [dokumentasi Android untuk pengujian Espresso](https://developer.android.com/training/testing/espresso), disarankan agar animasi sistem dimatikan saat menguji pada perangkat nyata. Device Farm secara otomatis menonaktifkan pengaturan **Skala Animasi Jendela, Skala** **Animasi Transisi, dan Skala** **Durasi Animator saat dijalankan dengan runner** pengujian instrumentasi Runner [JUnitandroid.support.test.Runner.Android](http://developer.android.com/reference/android/support/test/runner/AndroidJUnitRunner.html).

**Perekam Uji**  
Device Farm mendukung framework, seperti Robotium, yang memiliki alat record-and-playback scripting.

## Penguraian uji mode standar
<a name="test-types-android-standard-mode-test-parse"></a>

Dalam mode standar run, Device Farm mem-parsing rangkaian pengujian Anda dan mengidentifikasi kelas pengujian unik dan metode yang akan dijalankan. Ini dilakukan melalui alat yang disebut [Dex Test Parser](https://github.com/linkedin/dex-test-parser). 

Saat diberi file .apk instrumentasi Android sebagai input, parser mengembalikan nama metode pengujian yang memenuhi syarat sepenuhnya yang cocok dengan konvensi JUnit 3 dan JUnit 4. 

Untuk menguji ini di lingkungan lokal: 

1. Unduh [https://github.com/linkedin/dex-test-parser](https://github.com/linkedin/dex-test-parser)biner.

1. Jalankan perintah berikut untuk mendapatkan daftar metode pengujian yang akan berjalan di Device Farm:

   ```
   java -jar parser.jar path/to/apk path/for/output
   ```

# Mengintegrasikan Instrumentasi Android dengan Device Farm
<a name="test-types-android-instrumentation-integrate"></a>

**catatan**  
Gunakan petunjuk berikut untuk mengintegrasikan pengujian instrumentasi Android dengan AWS Device Farm. Untuk informasi selengkapnya tentang menggunakan pengujian instrumentasi di Device Farm, lihat[Instrumentasi untuk Android dan AWS Device Farm](test-types-android-instrumentation.md). 

## Unggah pengujian instrumentasi Android Anda
<a name="test-types-android-instrumentation-upload"></a>

Gunakan konsol Device Farm untuk mengunggah pengujian Anda.

1. Masuk ke konsol Device Farm di [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).

1. Pada panel navigasi Device Farm, pilih **Pengujian Perangkat Seluler**, lalu pilih **Proyek**.

1. Dalam daftar proyek, pilih proyek yang ingin Anda unggah pengujian.
**Tip**  
Anda dapat menggunakan bilah pencarian untuk memfilter daftar proyek berdasarkan nama.  
Untuk membuat proyek, ikuti instruksi di[Membuat proyek di AWS Device Farm](how-to-create-project.md).

1. Pilih **Buat jalankan**.

1. Di bawah **Pilih aplikasi**, di bagian **Opsi pemilihan aplikasi**, pilih **Unggah aplikasi sendiri**.

1. Jelajahi dan pilih file aplikasi Android Anda. File harus berupa file.apk.

1. Di bawah **Configure test**, di bagian **Select test framework**, pilih **Instrumentation**, lalu **pilih Choose File**.

1. Jelajahi dan pilih file.apk yang berisi pengujian Anda.

1. Lengkapi instruksi yang tersisa untuk memilih perangkat dan mulai menjalankan.

## (Opsional) Ambil tangkapan layar dalam pengujian instrumentasi Android
<a name="test-types-android-instrumentation-screenshots"></a>

Anda dapat mengambil tangkapan layar sebagai bagian dari pengujian Instrumentasi Android Anda.

Untuk mengambil tangkapan layar, hubungi salah satu metode berikut:
+ Untuk Robotium, panggil `takeScreenShot` metode (misalnya,`solo.takeScreenShot();`).
+ Untuk Spoon, panggil `screenshot` metode, misalnya:

  ```
  Spoon.screenshot(activity, "initial_state");
  /* Normal test code... */
  Spoon.screenshot(activity, "after_login");
  ```

Selama uji coba, Device Farm mendapatkan tangkapan layar dari lokasi berikut di perangkat, jika ada, lalu menambahkannya ke laporan pengujian:
+ `/sdcard/robotium-screenshots`
+ `/sdcard/test-screenshots`
+ `/sdcard/Download/spoon-screenshots/test-class-name/test-method-name`
+ `/data/data/application-package-name/app_spoon-screenshots/test-class-name/test-method-name`

# Pengujian iOS di AWS Device Farm
<a name="test-types-ios-tests"></a>

Device Farm menyediakan dukungan untuk beberapa jenis pengujian otomatisasi untuk perangkat iOS, dan pengujian bawaan.

Untuk informasi selengkapnya tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

## Kerangka kerja pengujian aplikasi iOS
<a name="test-types-framework-ios"></a>

Tes berikut tersedia untuk perangkat iOS.
+ [Tes Appium otomatisMengintegrasikan dengan tes Appium](test-types-appium.md)
+ [XCTest](test-types-ios-xctest.md)
+ [XCTest UI](test-types-ios-xctest-ui.md)

## Jenis pengujian bawaan untuk iOS
<a name="test-types-built-in-ios"></a>

Saat ini ada satu jenis pengujian bawaan yang tersedia untuk perangkat iOS.
+ [Bawaan: fuzz (Android dan iOS)](test-types-built-in-fuzz.md)

# Mengintegrasikan Device Farm dengan XCTest iOS
<a name="test-types-ios-xctest"></a>

Dengan Device Farm, Anda dapat menggunakan XCTest framework untuk menguji aplikasi di perangkat nyata. Untuk informasi selengkapnya XCTest, lihat [Dasar-dasar Pengujian](https://developer.apple.com/library/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/03-testing_basics.html) dalam *Pengujian dengan Xcode*.

Untuk menjalankan pengujian, Anda membuat paket untuk uji coba, dan Anda mengunggah paket ini ke Device Farm.

Untuk informasi selengkapnya tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

**Topics**
+ [Buat paket untuk Anda XCTest jalankan](#test-types-ios-xctest-create-packages)
+ [Unggah paket untuk Anda XCTest jalankan ke Device Farm](#test-types-ios-xctest-upload)

## Buat paket untuk Anda XCTest jalankan
<a name="test-types-ios-xctest-create-packages"></a>

Untuk menguji aplikasi Anda dengan menggunakan XCTest framework, Device Farm memerlukan hal berikut:
+ Paket aplikasi Anda sebagai `.ipa` file.
+  XCTest Paket Anda sebagai `.zip` file.

Anda membuat paket-paket ini dengan menggunakan output build yang dihasilkan Xcode. Selesaikan langkah-langkah berikut untuk membuat paket sehingga Anda dapat mengunggahnya ke Device Farm.

**Untuk menghasilkan output build untuk aplikasi Anda**

1. Buka project aplikasi Anda di Xcode.

1. Di menu tarik-turun skema di toolbar Xcode, pilih Perangkat **iOS** Generik sebagai tujuan.

1. Di menu **Produk**, pilih **Build For**, lalu pilih **Testing**.

**Untuk membuat paket aplikasi**

1. Di navigator proyek di Xcode, di bawah **Produk**, buka menu kontekstual untuk file bernama. `app-project-name.app` Kemudian, pilih **Tampilkan di Finder**. Finder membuka folder bernama`Debug-iphoneos`, yang berisi output yang dihasilkan Xcode untuk build pengujian Anda. Folder ini termasuk `.app` file Anda.

1. Di Finder, buat folder baru, dan beri nama`Payload`.

1. Salin `app-project-name.app` file, dan tempel di `Payload` folder.

1. Buka menu kontekstual untuk `Payload` folder dan pilih **Kompres “Payload**”. Sebuah file bernama `Payload.zip` dibuat.

1. Ubah nama file dan ekstensi `Payload.zip` ke`app-project-name.ipa`.

   Pada langkah selanjutnya, Anda memberikan file ini ke Device Farm. Untuk membuat file lebih mudah ditemukan, Anda mungkin ingin memindahkannya ke lokasi lain, seperti desktop Anda.

1. Secara opsional, Anda dapat menghapus `Payload` folder dan `.app` file di dalamnya.

**Untuk membuat XCTest paket**

1. Di Finder, di `Debug-iphoneos` direktori, buka menu kontekstual untuk file tersebut. `app-project-name.app` Kemudian, pilih **Show Package Contents**.

1. Dalam isi paket, buka `Plugins` folder. Folder ini berisi file bernama`app-project-name.xctest`.

1. Buka menu kontekstual untuk file ini dan pilih **Kompres "” `app-project-name.xctest`**. Sebuah file bernama `app-project-name.xctest.zip` dibuat.

   Pada langkah selanjutnya, Anda memberikan file ini ke Device Farm. Untuk membuat file lebih mudah ditemukan, Anda mungkin ingin memindahkannya ke lokasi lain, seperti desktop Anda.

## Unggah paket untuk Anda XCTest jalankan ke Device Farm
<a name="test-types-ios-xctest-upload"></a>

Gunakan konsol Device Farm untuk mengunggah paket untuk pengujian Anda.

1. Masuk ke konsol Device Farm di [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).

1. Jika Anda belum memiliki proyek, buat satu. Untuk langkah-langkah membuat proyek, lihat[Membuat proyek di AWS Device Farm](how-to-create-project.md).

   Jika tidak, pada panel navigasi Device Farm, pilih **Pengujian Perangkat Seluler**, lalu pilih **Proyek**.

1. Pilih proyek yang ingin Anda gunakan untuk menjalankan pengujian.

1. Pilih **Buat jalankan**.

1. Di bawah **Run settings**, di bagian **Run type**, pilih **iOS app**.

1. Di bawah **Pilih aplikasi**, di bagian **Opsi pemilihan aplikasi**, pilih **Unggah aplikasi sendiri**. Kemudian, pilih **Pilih file** di bawah **Unggah aplikasi**.

1. Jelajahi `.ipa` file untuk aplikasi Anda dan unggah.
**catatan**  
`.ipa`Paket Anda harus dibangun untuk pengujian.

1. Di bawah **Configure test**, di bagian **Select test framework**, pilih **XCTest**. Kemudian, pilih **Pilih file** di bawah **Unggah aplikasi**.

1. Jelajahi `.zip` file yang berisi XCTest paket untuk aplikasi Anda dan unggah.

1. Selesaikan langkah-langkah yang tersisa dalam proses pembuatan proyek. Anda akan memilih perangkat yang ingin Anda uji dan menentukan status perangkat.

1. Pilih **Buat jalankan**. Device Farm menjalankan pengujian Anda dan menunjukkan hasilnya di konsol.

# Mengintegrasikan XCTest UI untuk iOS dengan Device Farm
<a name="test-types-ios-xctest-ui"></a>

Device Farm menyediakan dukungan untuk framework pengujian XCTest UI. [Secara khusus, Device Farm mendukung pengujian XCTest UI yang ditulis dalam Objective-C dan Swift.](https://developer.apple.com/swift/) 

 Kerangka kerja XCTest UI memungkinkan pengujian UI dalam pengembangan iOS, dibangun di atasnya XCTest. Untuk informasi selengkapnya, lihat [Pengujian Antarmuka Pengguna](https://developer.apple.com/library/prerelease/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/09-ui_testing.html#//apple_ref/doc/uid/TP40014132-CH13-SW1) di Pustaka Pengembang iOS.

Untuk informasi umum tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

Gunakan petunjuk berikut untuk mengintegrasikan Device Farm dengan framework pengujian XCTest UI untuk iOS.

**Topics**
+ [Siapkan pengujian XCTest UI iOS Anda](#test-types-ios-xctest-ui-prepare)
+ [Opsi 1: Membuat XCTest paket.ipa UI](#how-to-use-create-XCTestUI-ipa-package)
+ [Opsi 2: Membuat paket XCTest UI.zip](#how-to-use-create-XCTestUI-zip-package)
+ [Unggah pengujian XCTest UI iOS Anda](#test-types-ios-xctest-ui-upload)

## Siapkan pengujian XCTest UI iOS Anda
<a name="test-types-ios-xctest-ui-prepare"></a>

Anda dapat mengunggah `.ipa` file atau `.zip` file untuk paket pengujian XCTEST\$1UI Anda.

`.ipa`File adalah arsip aplikasi yang berisi aplikasi iOS Runner dalam format bundel. *File tambahan tidak dapat disertakan di dalam `.ipa` file.*

Jika Anda mengunggah `.zip` file, file tersebut dapat berisi aplikasi iOS Runner secara langsung atau `.ipa` file. Anda juga dapat menyertakan file lain dalam `.zip` file jika Anda ingin menggunakannya selama pengujian. Misalnya Anda dapat menyertakan file seperti`.xctestrun`, `.xcworkspace` atau `.xcodeproj` di dalam `.zip` file untuk menjalankan Rencana Uji XCUI di peternakan perangkat. Instruksi terperinci tentang cara menjalankan Rencana Uji tersedia di file spesifikasi pengujian default untuk jenis Uji XCUI. 

## Opsi 1: Membuat XCTest paket.ipa UI
<a name="how-to-use-create-XCTestUI-ipa-package"></a>

Bundel *yourAppName*UITest-Runner.app diproduksi oleh Xcode saat Anda membangun proyek untuk pengujian. Hal ini dapat ditemukan di direktori Produk untuk proyek Anda.

Untuk membuat file.ipa:

1. Buat direktori yang disebut*Payload*.

1. Tambahkan direktori aplikasi Anda ke direktori Payload.

1. Arsipkan direktori Payload ke dalam `.zip` file dan kemudian ubah ekstensi file menjadi`.ipa`.

 Struktur folder berikut menunjukkan bagaimana contoh aplikasi bernama *my-project-nameUITest-Runner.app* akan dikemas sebagai `.ipa` file: 

```
.
└── my-project-nameUITest.ipa
    └── Payload (directory)
        └── my-project-nameUITest-Runner.app
```

## Opsi 2: Membuat paket XCTest UI.zip
<a name="how-to-use-create-XCTestUI-zip-package"></a>

Device Farm secara otomatis menghasilkan `.xctestrun` file untuk Anda untuk menjalankan rangkaian pengujian XCTest UI lengkap Anda. Jika Anda ingin menggunakan `.xctestrun` file Anda sendiri di Device Farm, Anda dapat mengompres `.xctestrun` file dan direktori aplikasi menjadi `.zip` file. Jika Anda sudah memiliki `.ipa` file untuk paket pengujian Anda, Anda dapat memasukkannya di sini alih-alih*\$1-Runner.app*.

```
.
└── swift-sample-UI.zip (directory)
   ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa
   ├── SampleTestPlan_2.xctestrun
   ├── SampleTestPlan_1.xctestrun
   └── (any other files)
```

 Jika Anda ingin menjalankan rencana pengujian Xcode untuk pengujian XCUI di Device Farm, Anda dapat membuat zip yang berisi file *my-project-nameUITest-Runner.app **atau my-project-name** *UITest.ipa** dan file kode sumber xcode yang diperlukan untuk menjalankan XCTEST\$1UI dengan rencana pengujian, termasuk file atau file. `.xcworkspace` `.xcodeproj`

Berikut adalah contoh zip menggunakan `.xcodeproj` file: 

```
.
└── swift-sample-UI.zip (directory)
   ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa
   ├── (any directory)
   └── SampleXcodeProject.xcodeproj
        ├── Testplan_1.xctestplan
        ├── Testplan_2.xctestplan
        └── (any other source code files created by xcode with .xcodeproj)
```

Berikut adalah contoh zip menggunakan `.xcworkspace` file: 

```
.
└──swift-sample-UI.zip (directory)
   ├── my-project-nameUITest-Runner.app [OR] my-project-nameUITest.ipa
   └── (any directory)
   │   ├── SampleXcodeProject.xcodeproj
   │   ├── Testplan_1.xctestplan
   │   ├── Testplan_2.xctestplan
   |   └── (any other source code files created by xcode with .xcodeproj)
   └── SampleWorkspace.xcworkspace
       └── contents.xcworkspacedata
```

**catatan**  
Harap pastikan bahwa Anda tidak memiliki direktori bernama “Payload” di dalam paket XCTest UI.zip Anda. 

## Unggah pengujian XCTest UI iOS Anda
<a name="test-types-ios-xctest-ui-upload"></a>

Gunakan konsol Device Farm untuk mengunggah pengujian Anda.

1. Masuk ke konsol Device Farm di [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).

1. Pada panel navigasi Device Farm, pilih **Pengujian Perangkat Seluler**, lalu pilih **Proyek**.

1. Dalam daftar proyek, pilih proyek yang ingin Anda unggah pengujian.
**Tip**  
Anda dapat menggunakan bilah pencarian untuk memfilter daftar proyek berdasarkan nama.  
Untuk membuat proyek, ikuti instruksi di [Membuat proyek di AWS Device Farm](how-to-create-project.md)

1. Pilih **Buat jalankan**.

1. Di bawah **Run settings**, di bagian **Run type**, pilih **iOS app**.

1. Di bawah **Pilih aplikasi**, di bagian **Opsi pemilihan aplikasi**, pilih **Unggah aplikasi sendiri**. Kemudian, pilih **Pilih file** di bawah **Unggah aplikasi**.

1. Jelajahi dan pilih file aplikasi iOS Anda. File harus berupa file.ipa.
**catatan**  
Pastikan file.ipa Anda dibuat untuk perangkat iOS dan bukan untuk simulator.

1. Di bawah **Configure test**, di bagian **Select test framework**, pilih **XCTest UI**. Kemudian, pilih **Pilih file** di bawah **Unggah aplikasi**.

1. Jelajahi dan pilih file.ipa atau.zip yang berisi runner uji XCTest UI iOS Anda. 

1. Selesaikan langkah-langkah yang tersisa dalam proses pembuatan run. Anda akan memilih perangkat yang ingin Anda uji dan secara opsional menentukan konfigurasi tambahan.

1. Pilih **Buat jalankan**. Device Farm menjalankan pengujian Anda dan menunjukkan hasilnya di konsol.

# Pengujian aplikasi web di AWS Device Farm
<a name="test-types-web-app-tests"></a>

Device Farm menyediakan pengujian dengan Appium untuk aplikasi web. Untuk informasi selengkapnya tentang menyiapkan pengujian Appium di Device Farm, lihat. [Jalankan pengujian Appium secara otomatis di Device Farm](test-types-appium.md)

Untuk informasi selengkapnya tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

## Aturan untuk perangkat terukur dan tidak terukur
<a name="web-app-tests-metered-unmetered-devices-rules"></a>

Pengukuran mengacu pada penagihan untuk perangkat. Secara default, perangkat Device Farm diukur dan Anda dikenakan biaya per menit setelah menit uji coba gratis habis. Anda juga dapat memilih untuk membeli perangkat yang tidak diukur, yang memungkinkan pengujian tanpa batas dengan biaya bulanan tetap. Untuk informasi selengkapnya tentang harga, lihat [Harga AWS Device Farm](https://aws.amazon.com/device-farm/).

Jika Anda memilih untuk memulai proses dengan kumpulan perangkat yang berisi perangkat iOS dan Android, ada aturan untuk perangkat terukur dan tidak terukur. Misalnya, jika Anda memiliki lima perangkat Android yang tidak diukur dan lima perangkat iOS yang tidak diukur, pengujian web Anda berjalan menggunakan perangkat yang tidak diukur.

 Berikut adalah contoh lain: Misalkan Anda memiliki lima perangkat Android yang tidak diukur dan 0 perangkat iOS yang tidak diukur. Jika Anda hanya memilih perangkat Android untuk menjalankan web, perangkat yang tidak diukur akan digunakan. Jika Anda memilih perangkat Android dan iOS untuk menjalankan web, metode penagihan diukur, dan perangkat yang tidak diukur tidak digunakan.

# Pengujian bawaan di AWS Device Farm
<a name="test-types-built-in-tests"></a>

Device Farm menyediakan dukungan untuk jenis pengujian bawaan untuk perangkat Android dan iOS. 

Dengan pengujian bawaan, Anda dapat menguji aplikasi di beberapa perangkat tanpa harus menulis dan memelihara skrip otomatisasi pengujian. Ini dapat menghemat waktu dan tenaga Anda, terutama ketika Anda memulai dengan Device Farm. Device Farm menawarkan jenis pengujian bawaan berikut:
+ [Bawaan: fuzz (Android dan iOS)](test-types-built-in-fuzz.md)— Tes fuzz secara acak mengirimkan peristiwa antarmuka pengguna ke perangkat dan kemudian melaporkan hasilnya.

Untuk informasi selengkapnya tentang kerangka pengujian dan pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).



# Menjalankan uji fuzz bawaan Device Farm (Android dan iOS)
<a name="test-types-built-in-fuzz"></a>

Tes fuzz bawaan Device Farm secara acak mengirimkan peristiwa antarmuka pengguna ke perangkat dan kemudian melaporkan hasilnya.

Untuk informasi selengkapnya tentang pengujian di Device Farm, lihat[Uji kerangka kerja dan pengujian bawaan di AWS Device Farm](test-types.md).

**Untuk menjalankan uji fuzz bawaan**

1. Masuk ke konsol Device Farm di [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm).

1. Pada panel navigasi Device Farm, pilih **Pengujian Perangkat Seluler**, lalu pilih **Proyek**.

1. Dalam daftar proyek, pilih proyek tempat Anda ingin menjalankan uji fuzz bawaan.
**Tip**  
Anda dapat menggunakan bilah pencarian untuk memfilter daftar proyek berdasarkan nama.  
Untuk membuat proyek, ikuti instruksi di[Membuat proyek di AWS Device Farm](how-to-create-project.md).

1. Pilih **Buat jalankan**.

1. Di bawah **Run settings**, pilih tipe run Anda di bagian **Run type**. Pilih **aplikasi Android** jika Anda tidak memiliki aplikasi yang siap untuk diuji, atau jika Anda sedang menguji aplikasi android (.apk). Pilih **aplikasi iOS** jika Anda menguji aplikasi iOS (.ipa).

1. Di bawah **Pilih aplikasi**, pilih **Pilih contoh aplikasi yang disediakan oleh Device Farm** jika Anda tidak memiliki aplikasi yang tersedia untuk pengujian. Jika Anda membawa aplikasi sendiri, pilih **Unggah aplikasi sendiri**, dan pilih file aplikasi Anda.

1. Di bawah **Configure test**, di bagian **Select test framework**, pilih **Built-in: Fuzz**.

1. Jika salah satu pengaturan berikut muncul, Anda dapat menerima nilai default atau menentukan sendiri:
   + **Jumlah peristiwa**: Tentukan angka antara 1 dan 10.000, yang mewakili jumlah peristiwa antarmuka pengguna untuk pengujian fuzz yang akan dilakukan.
   + **Event throttle**: Tentukan angka antara 0 dan 1.000, mewakili jumlah milidetik untuk pengujian fuzz menunggu sebelum melakukan acara antarmuka pengguna berikutnya.
   + **Biji pengacak**: Tentukan nomor untuk uji fuzz yang akan digunakan untuk mengacak peristiwa antarmuka pengguna. Menentukan nomor yang sama untuk tes fuzz berikutnya memastikan urutan peristiwa yang identik.

1. Lengkapi instruksi yang tersisa untuk memilih perangkat dan mulai menjalankan.