Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # Frameworks de test et tests intégrés dans AWS Device Farm Cette section décrit le support de Device Farm pour les frameworks de test et les types de tests intégrés. Device Farm exécute des tests automatisés en vous demandant de télécharger votre application et vos tests dans un compartiment Amazon S3 sécurisé géré par le service. Une fois chargé, il active l'infrastructure sous-jacente, y compris les [hôtes de test](custom-test-environments-hosts.md) gérés par les services, et exécute les tests en parallèle sur plusieurs appareils. Les résultats des tests sont stockés dans un compartiment S3 géré par le service. Cette architecture, appelée **exécution côté service**, constitue un moyen rapide et efficace d'exécuter des tests sur des hôtes physiquement proches de l'appareil, sans avoir à gérer vous-même l'infrastructure hôte de test. Cette approche s'adapte bien aux tests indépendants sur de nombreux appareils, ainsi qu'aux tests dans le contexte d'un CI/CD pipeline. Pour plus d'informations sur la manière dont Device Farm exécute les tests, consultez[Environnements de test dans AWS Device Farm](test-environments.md). **Note** Pour les testeurs Appium, vous préférerez peut-être exécuter vos tests Appium depuis votre environnement local. Avec une [session d'accès à distance](remote-access.md), vous pouvez exécuter des tests **Appium côté client**. Pour plus d'informations, veuillez consulter les tests [Appium côté client](appium-endpoint.md). ## Frameworks de test Device Farm prend en charge les frameworks de test d'automatisation mobiles suivants : ### Cadres de test d'applications Android + [Tests Appium automatiquesIntégration aux tests Appium](test-types-appium.md) + [Instrumentation](test-types-android-instrumentation.md) ### Cadres de test d'applications iOS + [Tests Appium automatiquesIntégration aux tests Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest UI](test-types-ios-xctest-ui.md) ### Cadres de test d'applications Web Les applications web sont prises en charge à l'aide d'Appium. Pour plus d'informations sur l'apport de vos tests à Appium, reportez-vous à la section [Exécuter automatiquement des tests Appium dans Device FarmIntégrer les tests Appium à Device Farm](test-types-appium.md). ### Frameworks dans un environnement de test personnalisé Device Farm ne fournit pas d'assistance pour la personnalisation de l'environnement de test pour le XCTest framework. Pour de plus amples informations, veuillez consulter [Environnements de test personnalisés dans AWS Device Farm](custom-test-environments.md). ### Support des versions d'Appium Pour les tests exécutés dans un environnement personnalisé, Device Farm prend en charge la version 1 d'Appium. Pour de plus amples informations, veuillez consulter [Environnements de test dans AWS Device Farm](test-environments.md). ## Types de tests intégrés Grâce aux tests intégrés, vous pouvez tester votre application sur plusieurs appareils sans avoir à écrire et à gérer des scripts d'automatisation des tests. Device Farm propose un type de test intégré : + [Intégré : Fuzz (Android et iOS)](test-types-built-in-fuzz.md) # Exécuter automatiquement des tests Appium dans Device Farm **Note** Cette page décrit l'exécution de tests Appium dans l'environnement d'exécution géré **côté serveur** de Device Farm. [Pour exécuter des tests Appium depuis votre environnement local **côté client** lors d'une session d'accès à distance, voir Tests Appium côté client.](appium-endpoint.md) Cette section décrit comment configurer, empaqueter et télécharger vos tests Appium pour les exécuter dans l'environnement géré côté serveur de Device Farm. Appium est un outil open source permettant d'automatiser les applications Web natives et mobiles. Pour plus d'informations, consultez la page de [présentation d'Appium](http://appium.io/docs/en/latest/intro) sur le site web Appium. Pour un exemple d'application et des liens vers des tests fonctionnels, voir [Device Farm Sample App pour Android](https://github.com/aws-samples/aws-device-farm-sample-app-for-android) et [Device Farm Sample App pour iOS](https://github.com/aws-samples/aws-device-farm-sample-app-for-ios) sur GitHub. Pour plus d'informations sur les tests dans Device Farm et sur le fonctionnement côté serveur, consultez. [Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md) ## Sélection d'une version d'Appium **Note** Support pour des versions spécifiques d'Appium, des pilotes Appium ou de la programmation SDKs dépend du périphérique et de l'hôte de test sélectionnés pour le test. Les hôtes de test Device Farm sont préinstallés avec Appium afin de permettre une configuration plus rapide des tests pour des cas d'utilisation plus simples. Cependant, l'utilisation du fichier de spécifications de test vous permet d'installer différentes versions d'Appium si nécessaire. ### Scénario 1 : version préconfigurée d'Appium Device Farm est préconfiguré avec différentes versions du serveur Appium en fonction de l'hôte de test. L'hôte est fourni avec des outils qui activent la version préconfigurée avec le pilote par défaut de la plate-forme de l'appareil (UiAutomator2 pour Android et pour XCUITest iOS). ``` phases: install: commands: - export APPIUM_VERSION=2 - devicefarm-cli use appium $APPIUM_VERSION ``` Pour consulter la liste des logiciels pris en charge, consultez la rubrique sur[Logiciels pris en charge dans des environnements de test personnalisés](custom-test-environments-hosts-software.md). ### Scénario 2 : version personnalisée d'Appium Pour sélectionner une version personnalisée d'Appium, utilisez la `npm` commande pour l'installer. L'exemple suivant montre comment installer la dernière version d'Appium 2. ``` phases: install: commands: - export APPIUM_VERSION=2 - npm install -g appium@$APPIUM_VERSION ``` ### Scénario 3 : Appium sur les anciens hôtes iOS Sur le[Ancien hôte de test iOS](custom-test-environments-hosts-ios.md#legacy-ios-host), vous pouvez choisir des versions spécifiques d'Appium avec. `avm` Par exemple, pour utiliser la `avm` commande permettant de définir la version du serveur Appium sur`2.1.2`, ajoutez ces commandes à votre fichier YAML de spécifications de test. ``` phases: install: commands: - export APPIUM_VERSION=2.1.2 - avm $APPIUM_VERSION ``` ## Sélection d'une WebDriverAgent version pour les tests iOS Pour exécuter des tests Appium sur des appareils iOS, l'utilisation de WebDriverAgent est requise. Cette application doit être signée pour être installée sur les appareils iOS. Device Farm fournit des versions pré-signées WebDriverAgent qui sont disponibles lors des exécutions d'environnements de test personnalisés. L'extrait de code suivant peut être utilisé pour sélectionner une WebDriverAgent version de Device Farm dans votre fichier de spécifications de test compatible avec la version de votre pilote d' XCTestinterface utilisateur. ``` 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; ``` [Pour plus d'informations à ce sujet WebDriverAgent, consultez la documentation d'Appium.](https://appium.github.io/appium-xcuitest-driver/9.10/guides/run-prebuilt-wda/) # Intégrer les tests Appium à Device Farm Suivez les instructions suivantes pour intégrer les tests Appium à AWS Device Farm. Pour plus d'informations sur l'utilisation des tests Appium dans Device Farm, consultez. [Exécuter automatiquement des tests Appium dans Device FarmIntégrer les tests Appium à Device Farm](test-types-appium.md) ## Configurez votre package de test Appium Utilisez les instructions suivantes pour configurer votre package de test. ------ #### [ Java (JUnit) ] 1. Modifiez `pom.xml` pour définir l'empaquetage dans un fichier JAR : ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifiez `pom.xml` pour utiliser `maven-jar-plugin` afin de créer vos tests dans un fichier JAR. Le plugin suivant crée votre code source de test (tout ce qui se trouve dans le `src/test` répertoire) dans un fichier JAR : ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifiez `pom.xml` pour utiliser `maven-dependency-plugin` afin de créer des dépendances en tant que fichiers JAR. Le plugin suivant copie vos dépendances dans le `dependency-jars` répertoire : ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Enregistrez l'assemblage XML suivant dans `src/main/assembly/zip.xml`. Le code XML suivant est une définition d'assemblage qui, une fois configurée, indique à Maven de créer un fichier .zip contenant tout ce qui se trouve à la racine du répertoire de sortie de votre build et du répertoire : `dependency-jars` ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifiez le fichier `pom.xml` pour utiliser `maven-assembly-plugin` afin de compresser tous les tests et les dépendances en un seul fichier .zip. Le plug-in suivant utilise l'assemblage précédant pour créer un fichier .zip nommé `zip-with-dependencies` dans le répertoire de sortie de build à chaque fois que la commande **mvn package** est exécutée : ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **Note** Si un message d'erreur indique que l'annotation n'est pas prise en charge dans la version 1.3, ajoutez les éléments suivants au fichier `pom.xml` : ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Java (TestNG) ] 1. Modifiez `pom.xml` pour définir l'empaquetage dans un fichier JAR : ``` com.acme acme-myApp-appium 1.0-SNAPSHOT jar ``` 1. Modifiez `pom.xml` pour utiliser `maven-jar-plugin` afin de créer vos tests dans un fichier JAR. Le plugin suivant crée votre code source de test (tout ce qui se trouve dans le `src/test` répertoire) dans un fichier JAR : ``` org.apache.maven.plugins maven-jar-plugin 2.6 test-jar ``` 1. Modifiez `pom.xml` pour utiliser `maven-dependency-plugin` afin de créer des dépendances en tant que fichiers JAR. Le plugin suivant copie vos dépendances dans le `dependency-jars` répertoire : ``` org.apache.maven.plugins maven-dependency-plugin 2.10 copy-dependencies package copy-dependencies ${project.build.directory}/dependency-jars/ ``` 1. Enregistrez l'assemblage XML suivant dans `src/main/assembly/zip.xml`. Le code XML suivant est une définition d'assemblage qui, une fois configurée, indique à Maven de créer un fichier .zip contenant tout ce qui se trouve à la racine du répertoire de sortie de votre build et du répertoire : `dependency-jars` ``` zip zip false ${project.build.directory} ./ *.jar ${project.build.directory} ./ /dependency-jars/ ``` 1. Modifiez le fichier `pom.xml` pour utiliser `maven-assembly-plugin` afin de compresser tous les tests et les dépendances en un seul fichier .zip. Le plug-in suivant utilise l'assemblage précédant pour créer un fichier .zip nommé `zip-with-dependencies` dans le répertoire de sortie de build à chaque fois que la commande **mvn package** est exécutée : ``` maven-assembly-plugin 2.5.4 package single zip-with-dependencies false src/main/assembly/zip.xml ``` **Note** Si un message d'erreur indique que l'annotation n'est pas prise en charge dans la version 1.3, ajoutez les éléments suivants au fichier `pom.xml` : ``` maven-compiler-plugin 1.7 1.7 ``` ------ #### [ Node.JS ] Pour empaqueter vos tests Appium Node.js et les télécharger sur Device Farm, vous devez installer les éléments suivants sur votre machine locale : + [Node Version Manager (nvm)](https://github.com/nvm-sh/nvm) Utilisez cet outil pour développer et créer vos packages de test afin qu'aucune dépendance inutile n'y soit incluse. + Node.js + npm-bundle (installé globalement) 1. Vérifiez que nvm est présent ``` command -v nvm ``` Vous devez voir `nvm` en tant que sortie. Pour plus d'informations, consultez [nvm](https://github.com/nvm-sh/nvm) on GitHub. 1. Pour installer Node.js, exécutez la commande suivante : ``` nvm install node ``` Vous pouvez spécifier une version particulière de Node.js : ``` nvm install 11.4.0 ``` 1. Vérifiez que la version correcte de Node est en cours d'utilisation : ``` node -v ``` 1. Installer **npm-bundle** globalement : ``` npm install -g npm-bundle ``` ------ #### [ Python ] 1. Nous vous recommandons vivement de configurer [virtualenv Python](https://pypi.python.org/pypi/virtualenv) pour le développement et la création d'un package de tests afin qu'aucune dépendance inutile ne soit incluse dans votre package d'application. ``` $ virtualenv workspace $ cd workspace $ source bin/activate ``` **Astuce** Ne créez pas d'environnement virtualenv Python avec l'option `--system-site-packages`, car il hérite des packages de votre répertoire site-packages global. Cela peut entraîner l'inclusion dans votre environnement virtuel de dépendances qui ne sont pas requises par vos tests. Vous devez également vérifier que vos tests n'utilisent pas de dépendances aux bibliothèques natives. En effet, il est possible que ces bibliothèques natives ne soient pas présentes sur l'instance sur laquelle ces tests sont exécutés. 1. Installez **py.test** dans votre environnement virtuel. ``` $ pip install pytest ``` 1. Installez le client Appium Python dans votre environnement virtuel. ``` $ pip install Appium-Python-Client ``` 1. À moins que vous ne spécifiiez un chemin différent en mode personnalisé, Device Farm s'attend à ce que vos tests y soient stockés`tests/`. Vous pouvez utiliser `find` pour afficher tous les fichiers dans un dossier : ``` $ find tests/ ``` Vérifiez que ces fichiers contiennent des suites de test que vous souhaitez exécuter sur Device Farm ``` tests/ tests/my-first-tests.py tests/my-second-tests/py ``` 1. Exécutez cette commande à partir du dossier workspace de votre environnement virtuel pour afficher une liste de vos tests sans les exécuter. ``` $ py.test --collect-only tests/ ``` Vérifiez que le résultat indique les tests que vous souhaitez exécuter sur Device Farm. 1. Nettoyez tous les fichiers mis en cache sous votre dossier tests/ : ``` $ 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. Exécutez la commande suivante dans votre espace de travail pour générer le fichier requirements.txt : ``` $ pip freeze > requirements.txt ``` ------ #### [ Ruby ] Pour empaqueter vos tests Appium Ruby et les télécharger sur Device Farm, vous devez installer les éléments suivants sur votre machine locale : + [Ruby Version Manager (RVM)](https://rvm.io/rvm/install) Utilisez cet outil de ligne de commande pour développer et créer vos packages de test afin qu'aucune dépendance inutile n'y soit incluse. + Ruby + Bundler (Cette gem est généralement installée avec Ruby.) 1. Installez les clés nécessaires, RVM et Ruby. Pour plus d'informations, consultez la [section relative à l'installation de RVM](https://rvm.io/rvm/install) sur le site Web RVM. Une fois l'installation terminée, rechargez votre terminal. Pour cela, déconnectez-vous puis reconnectez-vous. **Note** RVM est chargé en tant que fonction pour le shell bash uniquement. 1. Vérifiez que **rvm** est installé correctement. ``` command -v rvm ``` Vous devez voir `rvm` en tant que sortie. 1. Si vous souhaitez installer une version spécifique de Ruby, par exemple*2.5.3*, exécutez la commande suivante : ``` rvm install ruby 2.5.3 --autolibs=0 ``` Vérifiez que vous êtes sur la version demandée de Ruby : ``` ruby -v ``` 1. Configurez le bundler pour compiler les packages pour les plateformes de test souhaitées : ``` bundle config specific_platform true ``` 1. Mettez à jour votre fichier .lock pour ajouter les plateformes nécessaires à l'exécution des tests. + Si vous compilez des tests à exécuter sur des appareils Android, exécutez cette commande pour configurer le Gemfile afin qu'il utilise les dépendances de l'hôte de test Android : ``` bundle lock --add-platform x86_64-linux ``` + Si vous compilez des tests à exécuter sur des appareils iOS, exécutez cette commande pour configurer le Gemfile afin qu'il utilise les dépendances de l'hôte de test iOS : ``` bundle lock --add-platform x86_64-darwin ``` 1. La gem **bundler** est généralement installée par défaut. Si ce n'est pas le cas, installez-la : ``` gem install bundler -v 2.3.26 ``` ------ ## Création d'un fichier de package de test compressé **Avertissement** Dans Device Farm, la structure des dossiers des fichiers de votre package de test compressé est importante, et certains outils d'archivage modifieront implicitement la structure de votre fichier ZIP. Nous vous recommandons de suivre les utilitaires de ligne de commande spécifiés ci-dessous plutôt que d'utiliser les utilitaires d'archivage intégrés au gestionnaire de fichiers de votre bureau local (tels que le Finder ou l'Explorateur Windows). Maintenant, groupez vos tests pour la batterie de périphériques. ------ #### [ Java (JUnit) ] Construisez et empaquetez vos tests : ``` $ mvn clean package -DskipTests=true ``` Le fichier `zip-with-dependencies.zip` sera créé en conséquence. Ceci est votre package de tests. ------ #### [ Java (TestNG) ] Construisez et empaquetez vos tests : ``` $ mvn clean package -DskipTests=true ``` Le fichier `zip-with-dependencies.zip` sera créé en conséquence. Ceci est votre package de tests. ------ #### [ Node.JS ] 1. Vérifiez votre projet. Assurez-vous d'être dans le répertoire racine de votre projet. Vous pouvez voir `package.json` dans le répertoire racine. 1. Pour installer vos dépendances locales, exécutez la commande suivante. ``` npm install ``` Cette commande crée également un dossier `node_modules` au sein de votre répertoire actuel. **Note** À ce stade, vous devriez être en mesure d'exécuter vos tests en local. 1. Exécutez cette commande pour regrouper les fichiers de votre dossier actif dans un package \$1.tgz. Le fichier créé est nommé en fonction de la propriété `name` indiquée dans votre fichier `package.json`. ``` npm-bundle ``` Ce fichier tarball (.tgz) contient votre code et toutes les dépendances. 1. Exécutez cette commande pour inclure le fichier tarball (\$1.tgz) généré à l'étape précédente dans une seule archive compressée : ``` zip -r MyTests.zip *.tgz ``` Il s'agit du `MyTests.zip` fichier que vous chargez sur Device Farm dans le cadre de la procédure suivante. ------ #### [ Python ] Python 2 Générez une archive des packages Python requis (appelé dossier wheelhouse) en utilisant pip : ``` $ pip wheel --wheel-dir wheelhouse -r requirements.txt ``` Regroupez votre dossier wheelhouse, vos tests et vos exigences concernant pip dans une archive zip pour Device Farm : ``` $ zip -r test_bundle.zip tests/ wheelhouse/ requirements.txt ``` Python 3 Regroupez vos tests et vos exigences concernant pip dans un fichier zip : ``` $ zip -r test_bundle.zip tests/ requirements.txt ``` ------ #### [ Ruby ] 1. Pour créer un environnement Ruby virtuel, exécutez cette commande : ``` # myGemset is the name of your virtual Ruby environment rvm gemset create myGemset ``` 1. Pour utiliser l'environnement que vous venez de créer, exécutez cette commande : ``` rvm gemset use myGemset ``` 1. Vérifiez votre code source. Assurez-vous d'être dans le répertoire racine de votre projet. Vous pouvez voir `Gemfile` dans le répertoire racine. 1. Pour installer vos dépendances locales et toutes les gems à partir du fichier `Gemfile`, exécutez cette commande : ``` bundle install ``` **Note** À ce stade, vous devriez être en mesure d'exécuter vos tests en local. Pour exécuter un test en local, utilisez cette commande : ``` bundle exec $test_command ``` 1. Regroupez vos gems dans le dossier `vendor/cache`. ``` # This will copy all the .gem files needed to run your tests into the vendor/cache directory bundle package --all-platforms ``` 1. Exécutez la commande suivante pour regrouper votre code source, ainsi que toutes vos dépendances, dans une seule archive compressée : ``` zip -r MyTests.zip Gemfile vendor/ $(any other source code directory files) ``` Il s'agit du `MyTests.zip` fichier que vous chargez sur Device Farm dans le cadre de la procédure suivante. ------ ## Téléchargez votre package de test sur Device Farm Vous pouvez utiliser la console Device Farm pour télécharger vos tests. 1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm). 1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**. 1. Si vous êtes un nouvel utilisateur, choisissez **Nouveau projet**, entrez un nom pour le projet, puis choisissez **Soumettre**. Si vous avez déjà un projet, vous pouvez le choisir pour y télécharger vos tests. 1. Ouvrez votre projet, puis choisissez **Create run**. 1. Sous **Paramètres d'exécution**, attribuez un nom approprié à votre test. Il peut contenir n'importe quelle combinaison d'espaces ou de ponctuation. 1. Pour les tests natifs Android et iOS Sous **Paramètres d'exécution**, choisissez **application Android** si vous testez une application Android (.apk) ou **application iOS** si vous testez une application iOS (.ipa). Ensuite, sous **Sélectionner une application**, sélectionnez **Télécharger votre propre application** pour télécharger le package distribuable de votre application. Le fichier doit être un fichier Android `.apk` ou un fichier iOS `.ipa`. Les applications iOS doivent être construites pour des appareils réels, et non pour le simulateur. Pour les tests d'application web mobile Sous **Paramètres d'exécution**, sélectionnez **Web App**. 1. Sous **Configurer le test**, dans la section **Sélectionner le framework de test**, choisissez le framework Appium avec lequel vous testez, puis **téléchargez votre propre package de test**. 1. Recherchez et choisissez le fichier .zip contenant vos tests. Le fichier .zip doit respecter le format décrit dans [Configurez votre package de test Appium](#test-types-appium-prepare). 1. Suivez les instructions pour sélectionner les appareils et démarrer l'exécution. Pour de plus amples informations, veuillez consulter [Création d'un test dans Device Farm](how-to-create-test-run.md). **Note** Device Farm ne modifie pas les tests Appium. ## Prenez des captures d'écran de vos tests (facultatif) Vous pouvez effectuer des captures d'écran dans le cadre de vos tests. Device Farm définit la propriété `DEVICEFARM_SCREENSHOT_PATH` sur un chemin d'accès complet du système de fichiers local, sur lequel Device Farm prévoit que les captures d'écran Appium seront enregistrées. Le répertoire spécifique au test dans lequel les captures d'écran sont stockées est défini lors de l'exécution. Les captures d'écran sont extraites automatiquement dans vos rapports Device Farm. Pour afficher les captures d'écran, dans la console Device Farm, choisissez la section **Screenshots (Captures d'écran)**. Pour plus d'informations sur la prise de captures d'écran dans les tests Appium, voir [Take Screenshot](http://appium.io/docs/en/commands/session/screenshot/) dans la documentation Appium API. # Tests Android dans AWS Device Farm Device Farm prend en charge plusieurs types de tests d'automatisation pour les appareils Android, ainsi que deux tests intégrés. Pour plus d'informations sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). ## Cadres de test d'applications Android Les tests suivants sont disponibles pour les appareils Android. + [Tests Appium automatiquesIntégration aux tests Appium](test-types-appium.md) + [Instrumentation](test-types-android-instrumentation.md) ## Types de tests intégrés pour Android Il existe un type de test intégré disponible pour les appareils Android : + [Intégré : Fuzz (Android et iOS)](test-types-built-in-fuzz.md) # Instrumentation pour Android et AWS Device Farm Device Farm prend en charge l'instrumentation (EspressoJUnit, Robotium ou tout autre test basé sur l'instrumentation) pour Android. Device Farm fournit également un exemple d'application Android et des liens vers des tests fonctionnels dans trois frameworks d'automatisation Android, dont Instrumentation (Espresso). L'[exemple d'application Device Farm pour Android](https://github.com/awslabs/aws-device-farm-sample-app-for-android) est disponible en téléchargement sur GitHub. Pour plus d'informations sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). **Topics** + [Qu'est-ce que l'instrumentation ?](#test-types-android-instrumentation-what-is) + [Considérations relatives aux tests d'instrumentation Android](#test-types-android-instrumentation-settings) + [Analyse syntaxique des tests en mode standard](#test-types-android-standard-mode-test-parse) + [Intégrer l'instrumentation Android à Device Farm](test-types-android-instrumentation-integrate.md) ## Qu'est-ce que l'instrumentation ? Instrumentation Android vous permet d'appeler des méthodes de rappel dans votre code de test, afin que vous puissiez parcourir le cycle de vie d'un composant étape par étape, comme si vous déboguiez le composant. Pour plus d'informations, consultez la section [Tests instrumentés](https://developer.android.com/studio/test/test-in-android-studio#test_types_and_locations) dans la section *Types et emplacements de tests* de la documentation des *outils de développement Android*. ## Considérations relatives aux tests d'instrumentation Android Lorsque vous utilisez l'instrumentation Android, tenez compte des recommandations et remarques suivantes. **Vérifiez la compatibilité du système d'exploitation Android** Consultez la [documentation Android](https://developer.android.com/jetpack/androidx/releases/test#orchestrator-1.5.0) pour vous assurer que l'instrumentation est compatible avec la version de votre système d'exploitation Android. **Exécution depuis la ligne de commande** Pour exécuter des tests d'instrumentation depuis la ligne de commande, veuillez suivre la [documentation Android.](https://developer.android.com/training/testing/instrumented-tests/androidx-test-libraries/runner#enable-command) **System Animations (Animations système)** Selon la [documentation Android pour les tests d'Espresso](https://developer.android.com/training/testing/espresso), il est recommandé de désactiver les animations du système lors des tests sur des appareils réels. Device Farm désactive automatiquement les paramètres **Window Animation Scale**, **Transition Animation Scale** et **Animator Duration Scale** lorsqu'il s'exécute avec le testeur d'instrumentation [JUnitandroid.support.test.runner.Android](http://developer.android.com/reference/android/support/test/runner/AndroidJUnitRunner.html) Runner. **Test Recorders (Enregistreurs de test)** Device Farm prend en charge les frameworks, tels que Robotium, dotés d'outils record-and-playback de script. ## Analyse syntaxique des tests en mode standard En mode standard d'exécution, Device Farm analyse votre suite de tests et identifie les classes et méthodes de test uniques qu'elle exécutera. Cela se fait par le biais d'un outil appelé [Dex Test Parser](https://github.com/linkedin/dex-test-parser). Lorsqu'un fichier .apk d'instrumentation Android est fourni en entrée, l'analyseur renvoie les noms de méthode complets des tests qui correspondent aux conventions JUnit 3 et JUnit 4. Pour tester cela dans un environnement local : 1. Téléchargez le [https://github.com/linkedin/dex-test-parser](https://github.com/linkedin/dex-test-parser)binaire. 1. Exécutez la commande suivante pour obtenir la liste des méthodes de test qui seront exécutées sur Device Farm : ``` java -jar parser.jar path/to/apk path/for/output ``` # Intégrer l'instrumentation Android à Device Farm **Note** Suivez les instructions suivantes pour intégrer les tests d'instrumentation Android à AWS Device Farm. Pour plus d'informations sur l'utilisation des tests d'instrumentation dans Device Farm, consultez[Instrumentation pour Android et AWS Device Farm](test-types-android-instrumentation.md). ## Téléchargez vos tests d'instrumentation Android Utilisez la console Device Farm pour télécharger vos tests. 1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm). 1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**. 1. Dans la liste des projets, choisissez le projet dans lequel vous souhaitez télécharger vos tests. **Astuce** Vous pouvez utiliser la barre de recherche pour filtrer la liste des projets par nom. Pour créer un projet, suivez les instructions fournies dans [Création d'un projet dans AWS Device Farm](how-to-create-project.md). 1. Sélectionnez **Créer une course**. 1. Sous **Sélectionner une application**, dans la section **Options de sélection des applications**, sélectionnez **Télécharger votre propre application**. 1. Recherchez et sélectionnez votre fichier d'application Android. Le fichier doit être au format .apk. 1. Sous **Configurer le test**, dans la section **Sélectionner le cadre de test**, choisissez **Instrumentation**, puis sélectionnez **Choisir un fichier**. 1. Recherchez et choisissez le fichier .apk contenant vos tests. 1. Suivez les instructions restantes pour sélectionner les appareils et démarrer l'exécution. ## (Facultatif) Prenez des captures d'écran lors des tests d'instrumentation Android Vous pouvez effectuer des captures d'écran dans le cadre de vos tests Instrumentation Android. Pour effectuer des captures d'écran, appelez l'une des méthodes suivantes : + Pour Robotium, appelez la méthode `takeScreenShot` (par exemple, `solo.takeScreenShot();`). + Pour Spoon, appelez la méthode `screenshot`, par exemple : ``` Spoon.screenshot(activity, "initial_state"); /* Normal test code... */ Spoon.screenshot(activity, "after_login"); ``` Lors d'un test, Device Farm obtient des captures d'écran des emplacements suivants sur les appareils, s'ils existent, puis les ajoute aux rapports de test : + `/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` # Tests iOS dans AWS Device Farm Device Farm prend en charge plusieurs types de tests d'automatisation pour les appareils iOS, ainsi qu'un test intégré. Pour plus d'informations sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). ## Cadres de test d'applications iOS Les tests suivants sont disponibles pour les appareils iOS. + [Tests Appium automatiquesIntégration aux tests Appium](test-types-appium.md) + [XCTest](test-types-ios-xctest.md) + [XCTest UI](test-types-ios-xctest-ui.md) ## Types de tests intégrés pour iOS Actuellement, il n'existe qu'un type de test intégré disponible pour les appareils iOS. + [Intégré : Fuzz (Android et iOS)](test-types-built-in-fuzz.md) # Intégration de Device Farm à XCTest pour iOS Avec Device Farm, vous pouvez utiliser le XCTest framework pour tester votre application sur de vrais appareils. Pour plus d'informations XCTest, consultez la section [Principes de base des tests](https://developer.apple.com/library/ios/documentation/DeveloperTools/Conceptual/testing_with_xcode/chapters/03-testing_basics.html) *dans Tester avec Xcode*. Pour exécuter un test, vous créez les packages pour votre test et vous les téléchargez sur Device Farm. Pour plus d'informations sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). **Topics** + [Créez les packages pour votre XCTest course](#test-types-ios-xctest-create-packages) + [Téléchargez les packages pour votre XCTest course sur Device Farm](#test-types-ios-xctest-upload) ## Créez les packages pour votre XCTest course Pour tester votre application à l'aide du XCTest framework, Device Farm a besoin des éléments suivants : + Votre package d'application en tant que fichier `.ipa`. + Votre XCTest package sous forme de `.zip` fichier. Vous créez ces packages en utilisant la sortie de build générée par Xcode. Procédez comme suit pour créer les packages afin de pouvoir les télécharger sur Device Farm. **Pour générer la sortie de build pour votre application.** 1. Ouvrez votre projet d'application dans Xcode. 1. Dans le menu déroulant de méthode de la barre d'outils Xcode, choisissez **Generic iOS Device (Appareil iOS générique)** comme destination. 1. Dans le menu **Product (Produit)**, choisissez **Build For (Build pour)**, puis **Testing (Test)**. **Pour créer le package d'application** 1. Dans le navigateur de projet dans Xcode, sous **Products (Produits)**, ouvrez le menu contextuel pour le fichier nommé `app-project-name.app`. Choisissez ensuite **Show in Finder (Afficher dans l'outil de recherche)**. L'outil de recherche s'ouvre dans un dossier nommé `Debug-iphoneos`, qui contient la sortie générée par Xcode pour votre build de test. Ce dossier inclut votre fichier `.app`. 1. Dans l'outil de recherche, créez un nouveau dossier et nommez-le `Payload`. 1. Copiez le fichier `app-project-name.app` et collez-le dans le dossier `Payload`. 1. Ouvrez le menu contextuel pour le dossier `Payload` et choisissez **Compress "Payload" (Compresser « Payload »)**. Un fichier nommé `Payload.zip` est créé. 1. Remplacez le nom de fichier et l'extension de `Payload.zip` par `app-project-name.ipa`. Dans une étape ultérieure, vous fournirez ce fichier à Device Farm. Pour rendre le fichier plus facile à trouver, vous pouvez le déplacer vers un autre emplacement, tel que votre bureau. 1. Le cas échéant, vous pouvez supprimer le dossier `Payload` et le fichier `.app` dans celui-ci. **Pour créer le XCTest package** 1. Dans l'outil de recherche, dans le répertoire `Debug-iphoneos`, ouvrez le menu contextuel pour le fichier `app-project-name.app`. Ensuite, choisissez **Show Package Contents (Afficher le contenu du package)**. 1. Dans le contenu du package, ouvrez le dossier `Plugins`. Ce dossier contient un fichier nommé `app-project-name.xctest`. 1. Ouvrez le menu contextuel pour ce fichier et choisissez **Compress (Compresser) "`app-project-name.xctest`"**. Un fichier nommé `app-project-name.xctest.zip` est créé. Dans une étape ultérieure, vous fournirez ce fichier à Device Farm. Pour rendre le fichier plus facile à trouver, vous pouvez le déplacer vers un autre emplacement, tel que votre bureau. ## Téléchargez les packages pour votre XCTest course sur Device Farm Utilisez la console Device Farm pour télécharger les packages de votre test. 1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm). 1. Si vous n'en possédez pas déjà un, créez un projet. Pour connaître les étapes de création d'un projet, consultez [Création d'un projet dans AWS Device Farm](how-to-create-project.md). Sinon, dans le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**. 1. Choisissez le projet que vous souhaitez utiliser pour exécuter le test. 1. Choisissez **Create run**. 1. Sous **Paramètres d'exécution**, dans la section **Type d'exécution**, choisissez **application iOS**. 1. Sous **Sélectionner une application**, dans la section **Options de sélection des applications**, sélectionnez **Télécharger votre propre application**. Sélectionnez ensuite **Choisir un fichier** sous **Télécharger l'application**. 1. Accédez au fichier `.ipa` pour votre application et chargez-le. **Note** Votre package `.ipa` doit être conçu pour les tests. 1. Sous **Configurer le test**, dans la section **Sélectionner le framework de test**, sélectionnez **XCTest**. Sélectionnez ensuite **Choisir un fichier** sous **Télécharger l'application**. 1. Accédez au `.zip` fichier contenant le XCTest package de votre application et téléchargez-le. 1. Effectuez les étapes restantes du processus de création de projet. Vous sélectionnerez les appareils sur lesquels vous souhaitez exécuter le test et vous spécifierez leur état. 1. Choisissez **Create run**. Device Farm exécute votre test et affiche les résultats dans la console. # Intégration de l' XCTest interface utilisateur pour iOS à Device Farm Device Farm fournit un support pour le framework de test de l' XCTest interface utilisateur. [Plus précisément, Device Farm prend en charge les tests d' XCTest interface utilisateur écrits à la fois en Objective-C et en Swift.](https://developer.apple.com/swift/) Le framework d' XCTest interface utilisateur permet de tester l'interface utilisateur dans le développement d'iOS, en s'appuyant sur XCTest. Pour plus d'informations, consultez [User Interface Testing](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) dans la bibliothèque pour les développeurs iOS. Pour obtenir des informations générales sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). Suivez les instructions ci-dessous pour intégrer Device Farm au framework de test de l' XCTest interface utilisateur pour iOS. **Topics** + [Préparez vos tests d' XCTest interface utilisateur iOS](#test-types-ios-xctest-ui-prepare) + [Option 1 : création d'un package d' XCTest interface utilisateur .ipa](#how-to-use-create-XCTestUI-ipa-package) + [Option 2 : création d'un package .zip d' XCTest interface utilisateur](#how-to-use-create-XCTestUI-zip-package) + [Téléchargez vos tests d' XCTest interface utilisateur iOS](#test-types-ios-xctest-ui-upload) ## Préparez vos tests d' XCTest interface utilisateur iOS Vous pouvez télécharger un `.ipa` fichier ou un `.zip` fichier pour votre package de test XCTEST\$1UI. Un `.ipa` fichier est une archive d'application contenant l'application iOS Runner sous forme de bundle. *Des fichiers supplémentaires ne peuvent pas être inclus dans le `.ipa` fichier.* Si vous importez un `.zip` fichier, il peut contenir directement l'application iOS Runner ou un `.ipa` fichier. Vous pouvez également inclure d'autres fichiers dans le `.zip` fichier si vous souhaitez les utiliser pendant les tests. Par exemple, vous pouvez inclure des fichiers tels que`.xctestrun`, `.xcworkspace` ou `.xcodeproj` dans un `.zip` fichier, pour exécuter des plans de test XCUI sur une ferme de périphériques. Des instructions détaillées sur la façon d'exécuter les plans de test sont disponibles dans le fichier de spécifications de test par défaut pour le type de test XCUI. ## Option 1 : création d'un package d' XCTest interface utilisateur .ipa Le bundle *yourAppName*UITest-Runner.app est produit par Xcode lorsque vous créez votre projet à des fins de test. Vous pouvez la trouver dans le répertoire Products de votre projet. Pour créer un fichier .ipa : 1. Créez un répertoire appelé*Payload*. 1. Ajoutez le répertoire de votre application au répertoire Payload. 1. Archivez le répertoire Payload dans un `.zip` fichier, puis remplacez l'extension du fichier par. `.ipa` La structure de dossiers suivante montre comment un exemple d'application nommé *my-project-nameUITest-Runner.app* serait empaqueté sous forme de `.ipa` fichier : ``` . └── my-project-nameUITest.ipa └── Payload (directory) └── my-project-nameUITest-Runner.app ``` ## Option 2 : création d'un package .zip d' XCTest interface utilisateur Device Farm génère automatiquement un `.xctestrun` fichier pour exécuter votre suite complète de tests d' XCTest interface utilisateur. Si vous souhaitez utiliser votre propre `.xctestrun` fichier sur Device Farm, vous pouvez compresser vos `.xctestrun` fichiers et le répertoire de l'application dans un `.zip` fichier. Si vous avez déjà un `.ipa` fichier pour votre package de test, vous pouvez l'inclure ici au lieu de*\$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) ``` Si vous souhaitez exécuter un plan de test Xcode pour vos tests XCUI sur Device Farm, vous pouvez créer un fichier zip contenant votre fichier *my-project-nameUITest-Runner.app **ou my-project-name** UITest .ipa* *et les fichiers de code source xcode nécessaires pour exécuter XCTEST\$1UI avec les plans de test, y compris un* fichier ou. `.xcworkspace` `.xcodeproj` Voici un exemple de zip utilisant un `.xcodeproj` fichier : ``` . └── 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) ``` Voici un exemple de zip utilisant un `.xcworkspace` fichier : ``` . └──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 ``` **Note** Vérifiez que le package .zip de votre XCTest interface utilisateur ne contient pas de répertoire nommé « Payload ». ## Téléchargez vos tests d' XCTest interface utilisateur iOS Utilisez la console Device Farm pour télécharger vos tests. 1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm). 1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**. 1. Dans la liste des projets, choisissez le projet dans lequel vous souhaitez télécharger vos tests. **Astuce** Vous pouvez utiliser la barre de recherche pour filtrer la liste des projets par nom. Pour créer un projet, suivez les instructions de [Création d'un projet dans AWS Device Farm](how-to-create-project.md) 1. Choisissez **Create run**. 1. Sous **Paramètres d'exécution**, dans la section **Type d'exécution**, choisissez **application iOS**. 1. Sous **Sélectionner une application**, dans la section **Options de sélection des applications**, sélectionnez **Télécharger votre propre application**. Sélectionnez ensuite **Choisir un fichier** sous **Télécharger l'application**. 1. Recherchez et sélectionnez votre fichier d'application iOS. Le fichier doit être au format .ipa. **Note** Assurez-vous que votre fichier .ipa est conçu pour un appareil iOS et non pour un simulateur. 1. Sous **Configurer le test**, dans la section **Sélectionner le framework de test**, choisissez **XCTest UI**. Sélectionnez ensuite **Choisir un fichier** sous **Télécharger l'application**. 1. Accédez au fichier .ipa ou .zip qui contient le lanceur de test de l' XCTest interface utilisateur iOS et choisissez-le. 1. Effectuez les étapes restantes du processus de création d'une course. Vous allez sélectionner les appareils sur lesquels vous souhaitez effectuer le test et éventuellement spécifier une configuration supplémentaire. 1. Choisissez **Create run**. Device Farm exécute votre test et affiche les résultats dans la console. # Tests d'applications Web dans AWS Device Farm Device Farm propose des tests avec Appium pour les applications Web. Pour plus d'informations sur la configuration de vos tests Appium sur Device Farm, consultez. [Exécuter automatiquement des tests Appium dans Device Farm](test-types-appium.md) Pour plus d'informations sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). ## Règles relatives aux appareils mesurés et non mesurés La notion d'appareils limités ou illimités fait référence à la facturation de leur utilisation. Par défaut, les appareils Device Farm sont équipés de compteurs et vous êtes facturé à la minute une fois les minutes d'essai gratuites épuisées. Vous pouvez également choisir d'acheter des appareils illimités, ce qui vous permet d'effectuer des tests de manière illimitée pour un coût mensuel fixe. Pour plus d'informations sur les tarifs, consultez la section [Tarifs d'AWS Device Farm](https://aws.amazon.com/device-farm/). Si vous choisissez de démarrer une exécution avec un groupe d'appareils contenant à la fois des appareils iOS et des appareils Android, certaines règles s'appliquent selon qu'ils sont limités ou illimités. Par exemple, si vous disposez de cinq appareils Android illimités et de cinq appareils iOS illimités, vos exécutions de test Web utilisent vos appareils illimités. Voici un autre exemple : supposons que vous disposiez de cinq appareils Android illimités et de 0 appareil iOS illimité. Si vous sélectionnez uniquement les appareils Android pour exécuter votre test Web, vos appareils illimités sont utilisés. Si vous sélectionnez à la fois les appareils Android et iOS pour exécuter votre test Web, le mode de facturation est limité et vos appareils illimités ne sont pas utilisés. # Tests intégrés dans AWS Device Farm Device Farm prend en charge les types de tests intégrés pour les appareils Android et iOS. Grâce aux tests intégrés, vous pouvez tester votre application sur plusieurs appareils sans avoir à écrire et à gérer des scripts d'automatisation des tests. Cela peut vous faire gagner du temps et économiser des efforts, en particulier lorsque vous débutez avec Device Farm. Device Farm propose le type de test intégré suivant : + [Intégré : Fuzz (Android et iOS)](test-types-built-in-fuzz.md)— Le fuzz test envoie aléatoirement des événements d'interface utilisateur aux appareils, puis rapporte les résultats. Pour plus d'informations sur les tests et les frameworks de test dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). # Exécution du test de fuzz intégré à Device Farm (Android et iOS) Le test de fuzz intégré à Device Farm envoie de manière aléatoire les événements de l'interface utilisateur aux appareils, puis communique les résultats. Pour plus d'informations sur les tests dans Device Farm, consultez[Frameworks de test et tests intégrés dans AWS Device Farm](test-types.md). **Pour exécuter le test de fuzz intégré** 1. Connectez-vous à la console Device Farm à l'adresse [https://console.aws.amazon.com/devicefarm](https://console.aws.amazon.com/devicefarm). 1. Sur le panneau de navigation de Device Farm, choisissez **Mobile Device Testing**, puis **Projects**. 1. Dans la liste des projets, choisissez le projet dans lequel vous souhaitez exécuter le test de fuzz intégré. **Astuce** Vous pouvez utiliser la barre de recherche pour filtrer la liste des projets par nom. Pour créer un projet, suivez les instructions fournies dans [Création d'un projet dans AWS Device Farm](how-to-create-project.md). 1. Choisissez **Create run**. 1. Sous **Paramètres d'exécution**, sélectionnez votre type d'exécution dans la section **Type d'exécution**. Sélectionnez une **application Android** si aucune application n'est prête à être testée ou si vous testez une application Android (.apk). Sélectionnez une **application iOS** si vous testez une application iOS (.ipa). 1. Sous **Select app**, choisissez **Select sample app fourni par Device Farm** si aucune application n'est disponible pour les tests. Si vous apportez votre propre application, sélectionnez **Télécharger votre propre application**, puis choisissez votre fichier de candidature. 1. Sous **Configurer le test**, dans la section **Sélectionner le framework de test**, choisissez **Built-in : Fuzz**. 1. Si l'un des paramètres suivants s'affiche, vous pouvez accepter les valeurs par défaut ou spécifier vos propres valeurs : + **Event count (Nombre d'événements)** : spécifiez un nombre compris entre 1 et 10 000, qui représente le nombre d'événements d'interface utilisateur que le test Fuzz doit effectuer. + **Limitation des événements** : spécifiez un nombre compris entre 0 et 1 000, représentant le nombre de millisecondes pendant lequel le test de fuzz doit attendre avant de réaliser le prochain événement d'interface utilisateur. + **Randomizer Seed (Valeur initiale de générateur aléatoire)** : spécifiez un nombre que le test Fuzz doit utiliser pour randomiser les événements d'interface utilisateur. Si vous spécifiez le même nombre pour les tests Fuzz suivants, les séquences d'événements seront identiques. 1. Suivez les instructions restantes pour sélectionner les appareils et démarrer l'exécution.