Il peut être difficile d'automatiser les tests lorsque les applications de jeu sont basées sur différents Frameworks d'UI. Les tests de boucle de jeu vous permettent d'intégrer vos tests natifs à Test Lab et exécutez-les facilement sur les appareils de votre choix. Un test de boucle de jeu exécute votre les tests dans votre application de jeu tout en simulant les actions d'un vrai joueur. Ce vous explique comment exécuter un test de boucle de jeu, puis comment l'afficher et le gérer dans la console Firebase.
En fonction de votre moteur de jeu, vous pouvez implémenter des tests avec une ou plusieurs boucles. Une boucle est une exécution complète ou partielle de votre test sur votre application de jeu. Les boucles de jeu permettent de:
- Exécutez un niveau de votre jeu comme le ferait un utilisateur final. Vous pouvez soit rédiger un script pour l'entrée de l'utilisateur, lui laisser celui-ci être inactif, soit remplacer le utilisateur avec une IA si cela a du sens dans votre jeu (par exemple, vous avez une voiture de course une application de jeu vidéo et une IA est déjà implémentée. Vous pouvez facilement déployer conducteur responsable des entrées utilisateur).
- Exécutez votre jeu avec le paramètre de qualité le plus élevé pour voir si les appareils le prennent en charge.
- Exécutez un test technique (compilez plusieurs nuanceurs, exécutez-les, vérifiez que le la sortie est conforme à vos attentes, etc.).
Vous pouvez exécuter un test de boucle de jeu sur un seul appareil, un ensemble d'appareils de test ou le Test Lab. Toutefois, nous vous déconseillons d'exécuter des tests de boucle de jeu sur des appareils, car ils ont des fréquences de trame graphiques inférieures à celles des appareils physiques.
Avant de commencer
Pour implémenter un test, vous devez d'abord configurer votre application pour les tests de boucle de jeu.
Dans le fichier manifeste de votre application, ajoutez un filtre d'intent à votre activité:
<activity android:name=".MyActivity"> <intent-filter> <action android:name="com.google.intent.action.TEST_LOOP"/> <category android:name="android.intent.category.DEFAULT"/> <data android:mimeType="application/javascript"/> </intent-filter> <intent-filter> ... (other intent filters here) </intent-filter> </activity>Cela permet à Test Lab de lancer votre jeu en le déclenchant avec un l'intention.
Dans votre code (nous vous recommandons d'insérer la déclaration de la méthode
onCreate), ajoutez la méthode suivantes:Kotlin+KTX
val launchIntent = intent if (launchIntent.action == "com.google.intent.action.TEST_LOOP") { val scenario = launchIntent.getIntExtra("scenario", 0) // Code to handle your game loop here }
Java
Intent launchIntent = getIntent(); if(launchIntent.getAction().equals("com.google.intent.action.TEST_LOOP")) { int scenario = launchIntent.getIntExtra("scenario", 0); // Code to handle your game loop here }
Cela permet à votre activité de vérifier l'intent qui la lance. Vous pouvez également ajoutez ce code plus tard si vous préférez (par exemple, après le chargement initial de votre jeu moteur).
Recommandation: à la fin du test, ajoutez:
Kotlin+KTX
yourActivity.finish()
Java
yourActivity.finish();
Cette action ferme votre application une fois le test de boucle de jeu terminé. Le test repose sur le framework d'UI de votre application pour lancer la boucle suivante, et la fermeture de votre application lui indique que le test est terminé.
Créer et exécuter un test de boucle de jeu
Après avoir configuré votre application pour les tests de boucle de jeu, vous pouvez immédiatement créer un et l'exécuter dans votre application de jeu. Vous pouvez choisir d'exécuter un test Test Lab à l'aide de la console Firebase ou de la commande gcloud interface de ligne de commande (CLI), ou sur un appareil local à l'aide de la boucle de test Administrateur.
Exécuter sur un appareil local
Test Loop Manager de Test Lab est une application Open Source qui vous aide intégrer des tests de boucle de jeu et les exécuter sur vos appareils locaux. Il permet également à vos que l'équipe d'assurance qualité exécute les mêmes boucles de jeu sur ses appareils.
Pour exécuter un test sur un appareil local à l'aide du gestionnaire de boucle de test:
- Téléchargez le Gestionnaire de boucle de test.
sur un téléphone ou une tablette, puis installez-la en exécutant la commande suivante:
adb install testloopmanager.apk
- Sur votre appareil, ouvrez l'application Test Loop Apps (Tester les applications en boucle) sur votre téléphone ou votre tablette. L'application affiche la liste des applications de votre appareil qui peut être exécuté avec des boucles de jeu. Si vous ne voyez pas votre application de jeu ici, assurez-vous votre filtre d'intent correspond à celui décrit à la première étape Avant de commencer.
- Sélectionnez votre application de jeu, puis le nombre de boucles que vous souhaitez exécuter. Remarque : À cette étape, vous pouvez choisir d'exécuter un sous-ensemble de boucles au lieu d'une seule boucle. Pour en savoir plus sur l'exécution de plusieurs boucles à la fois, consultez la section Fonctionnalités facultatives.
- Cliquez sur Run test (Exécuter le test). Votre test commence immédiatement.
Exécuter dans Test Lab
Vous pouvez exécuter un test de boucle de jeu dans Test Lab à l'aide de la console Firebase ou de la CLI gcloud. Avant de commencer Si ce n'est pas déjà fait, ouvrez Console Firebase et créer un projet.
Utiliser la console Firebase
- Dans la console Firebase, cliquez sur Test Lab dans le panneau de gauche.
- Cliquez sur Exécuter votre premier test (ou sur Exécuter un test si votre projet a déjà exécuté un test).
- Sélectionnez Game Loop (Boucle de jeu) comme type de test, puis cliquez sur Continue (Continuer).
- Cliquez sur Parcourir, puis recherchez le fichier
.apkde votre application. Remarque: À cette étape, vous pouvez choisir d'exécuter un sous-ensemble de boucles au lieu une boucle. Pour en savoir plus sur l'exécution de plusieurs boucles en même temps, Fonctionnalités facultatives - Cliquez sur Continuer.
- Sélectionnez les appareils physiques à utiliser pour tester votre application.
- Cliquez sur Lancer les tests.
Pour en savoir plus sur la prise en main de la console Firebase, consultez Commencez les tests avec la console Firebase.
Utiliser la ligne de commande gcloud (CLI)
Si ce n'est pas déjà fait, téléchargez et installez le SDK Google Cloud.
Connectez-vous à la gcloud CLI à l'aide de votre compte Google :
gcloud auth loginDéfinissez votre projet Firebase dans gcloud, où
PROJECT_IDcorrespond à ID de votre projet Firebase:gcloud config set project PROJECT_ID
Exécutez votre premier test :
gcloud firebase test android run \ --type=game-loop --app=<var>path-to-apk</var> \ --device model=herolte,version=23
Pour en savoir plus sur la gcloud CLI, consultez la page Commencez les tests à partir de la ligne de commande gcloud.
Fonctionnalités facultatives
Test Lab propose plusieurs fonctionnalités facultatives qui vous permettent de personnaliser davantage votre y compris la possibilité d'écrire des données de sortie, la prise en charge de plusieurs boucles et étiquettes pour les boucles associées.
Écrire les données de sortie
Votre test de boucle de jeu peut écrire la sortie dans un fichier spécifié dans la méthode launchIntent.getData(). Après avoir exécuté un test, vous pouvez accéder
des données de sortie dans la section Test Lab de la console Firebase (consultez
Exemple de fichier de sortie de test de boucle de jeu).
Test Lab applique les bonnes pratiques de partage de fichier entre les applications décrites dans
Partager un fichier.
Dans la méthode onCreate() de votre activité, où se trouve votre intent,
pouvez vérifier votre fichier de sortie de données en exécutant le code suivant:
Kotlin+KTX
val launchIntent = intent val logFile = launchIntent.data logFile?.let { Log.i(TAG, "Log file ${it.encodedPath}") // ... }
Java
Intent launchIntent = getIntent(); Uri logFile = launchIntent.getData(); if (logFile != null) { Log.i(TAG, "Log file " + logFile.getEncodedPath()); // ... }
Si vous souhaitez écrire dans le fichier à partir du côté C++ de votre application de jeu, vous pouvez transmettre le descripteur de fichier au lieu du chemin d'accès au fichier :
Kotlin+KTX
val launchIntent = intent val logFile = launchIntent.data var fd = -1 logFile?.let { Log.i(TAG, "Log file ${it.encodedPath}") fd = try { contentResolver .openAssetFileDescriptor(logFile, "w")!! .parcelFileDescriptor .fd } catch (e: FileNotFoundException) { e.printStackTrace() -1 } catch (e: NullPointerException) { e.printStackTrace() -1 } } // C++ code invoked here. // native_function(fd);
Java
Intent launchIntent = getIntent(); Uri logFile = launchIntent.getData(); int fd = -1; if (logFile != null) { Log.i(TAG, "Log file " + logFile.getEncodedPath()); try { fd = getContentResolver() .openAssetFileDescriptor(logFile, "w") .getParcelFileDescriptor() .getFd(); } catch (FileNotFoundException e) { e.printStackTrace(); fd = -1; } catch (NullPointerException e) { e.printStackTrace(); fd = -1; } } // C++ code invoked here. // native_function(fd);
C++
#include <unistd.h> JNIEXPORT void JNICALL Java_my_package_name_MyActivity_native_function(JNIEnv *env, jclass type, jint log_file_descriptor) { // The file descriptor needs to be duplicated. int my_file_descriptor = dup(log_file_descriptor); }
Exemple de fichier de sortie
Vous pouvez utiliser des fichiers de données de sortie (formatés comme dans l'exemple ci-dessous) pour afficher le jeu
les résultats du test en boucle dans la section Test Lab de la console Firebase.
Les zones affichées sous la forme /.../ peuvent contenir tous les champs personnalisés dont vous avez besoin, à condition qu'ils ne soient pas en conflit avec les noms d'autres champs utilisés dans ce fichier :
{
"name": "test name",
"start_timestamp": 0, // Timestamp of the test start (in us).
Can be absolute or relative
"driver_info": "...",
"frame_stats": [
{
"timestamp": 1200000, // Timestamp at which this section was written
It contains value regarding the period
start_timestamp(0) -> this timestamp (1200000 us)
"avg_frame_time": 15320, // Average time to render a frame in ns
"nb_swap": 52, // Number of frame rendered
"threads": [
{
"name": "physics",
"Avg_time": 8030 // Average time spent in this thread per frame in us
},
{
"name": "AI",
"Avg_time": 2030 // Average time spent in this thread per frame in us
}
],
/.../ // Any custom field you want (vertices display on the screen, nb units …)
},
{
// Next frame data here, same format as above
}
],
"loading_stats": [
{
"name": "assets_level_1",
"total_time": 7850, // in us
/.../
},
{
"name": "victory_screen",
"total_time": 554, // in us
/.../
}
],
/.../, // You can add custom fields here
}
Boucles de jeu multiples
Il peut être utile d'exécuter plusieurs boucles de jeu dans votre application. Une boucle est un le cycle complet de votre application de jeu, du début à la fin. Par exemple, si vous comporte plusieurs niveaux, vous pouvez avoir une boucle de jeu lancer chaque niveau au lieu d'avoir une boucle qui itère tous. Ainsi, si votre application plante au niveau 32, vous pouvez lancer directement cette boucle de jeu pour reproduire le plantage et tester les corrections de bugs.
Pour permettre à votre application d'exécuter plusieurs boucles à la fois:
Si vous exécutez un test avec le gestionnaire de boucle de test:
Ajoutez la ligne suivante au fichier manifeste de votre application, dans le Élément
<application>:<meta-data android:name="com.google.test.loops" android:value="5" />
Cet intent de lancement contient la boucle cible sous la forme d'un paramètre d'entier. Dans le champ
android:value, vous pouvez spécifier un entier compris entre 1 et 1 024 (le (nombre maximal de boucles autorisé par test). Remarque que les boucles sont indexées à partir de 1, et non de 0.Dans l'application Test Loop Manager, un écran de sélection s'affiche : vous permet de sélectionner la ou les boucles que vous souhaitez exécuter. Si vous sélectionnez plusieurs boucles, chaque boucle est lancée dans l'ordre après la boucle précédente terminé.
Si vous exécutez un test avec la console Firebase, saisissez une liste ou un plage de nombres de boucles dans le champ Scénarios.
Si vous exécutez un test avec la gcloud CLI, spécifiez une liste de numéros de boucle à l'aide de l'option
--scenario-numbers. Par exemple,--scenario-numbers=1,3,5exécute les boucles 1, 3 et 5.Si vous écrivez en C++ et souhaitez modifier le comportement de votre boucle, transmettez la méthode supplémentaires à votre code C++ natif:
Kotlin+KTX
val launchIntent = intent val scenario = launchIntent.getIntExtra("scenario", 0)
Java
Intent launchIntent = getIntent(); int scenario = launchIntent.getIntExtra("scenario", 0);
Vous pouvez maintenant modifier le comportement de votre boucle en fonction du
intobtenu. .
Étiqueter les boucles de jeu
Lorsque vous attribuez un ou plusieurs libellés de scénario à vos boucles de jeu, vous et votre équipe de contrôle qualité pouvez facilement lancer un ensemble de boucles de jeu associées (par exemple, "toutes les compatibilités boucles de jeu") et les tester dans une seule matrice. Vous pouvez créer vos propres libellés utilisez les étiquettes prédéfinies proposées par Test Lab:
com.google.test.loops.player_experience: boucles For utilisées pour reproduire l'expérience d'un utilisateur réel lorsqu'il joue au jeu. L'objectif de les tests avec ces boucles consiste à trouver les problèmes auxquels un utilisateur réel serait confronté le jeu.com.google.test.loops.gpu_compatibility: boucles For utilisées pour tester Problèmes liés au GPU. L'objectif des tests avec ces boucles est d'exécuter des GPU susceptibles de ne pas s'exécuter correctement en production, afin d'exposer du matériel et des pilotes.com.google.test.loops.compatibility: boucles For utilisées pour tester un de nombreux problèmes de compatibilité, y compris les problèmes d'E/S et OpenSSL les problèmes de sécurité.com.google.test.loops.performance: boucles For utilisées pour tester le les performances de l'appareil. Par exemple, un jeu peut s'exécuter au niveau le plus complexe paramètres graphiques pour voir comment un nouvel appareil se comporte.
Pour permettre à votre application d'exécuter des boucles portant le même libellé:
Si vous exécutez un test avec le Gestionnaire de boucle de test :
Dans le fichier manifeste de votre application, ajoutez la ligne de métadonnées suivante et remplacez LABEL_NAME par le libellé de votre choix:
<meta-data android:name="com.google.test.loops.LABEL_NAME" android:value="1,3-5" />
Dans le champ
android:value, vous pouvez spécifier une plage ou un ensemble d'entiers. comprise entre 1 et 1 024 (le nombre maximal de boucles autorisé pour un seul test) qui représentent les boucles auxquelles vous souhaitez ajouter une étiquette. Notez que les boucles sont indexées au début de 1, et non de 0. Par exemple,android:value="1,3-5"s'applique LABEL_NAME pour les boucles 1, 3, 4 et 5.Dans l'application Gestionnaire de boucles de test, saisissez un ou plusieurs libellés dans le champ Libellés.
Si vous exécutez un test avec la console Firebase, saisissez une ou plusieurs des étiquettes dans le champ Libellés.
Si vous exécutez un test avec la gcloud CLI, spécifiez une ou plusieurs étiquettes de scénario en utilisant L'option
--scenario-labels(par exemple,--scenario-labels=performance,gpu).
Assistance pour l'attribution de licences d'application
Test Lab est compatible avec les applications qui utilisent les Gestion des licences d'application de Google Play. Pour vérifier les licences lors des tests votre application avec Test Lab, vous devez la publier en version de production sur le Play Store. Pour tester votre application en version alpha ou bêta à l'aide de Test Lab, supprimez la vérification des licences avant d'importer votre application dans Test Lab
Problèmes connus
Les tests de boucle de jeu dans Test Lab présentent les problèmes connus suivants :
- Certains plantages ne sont pas compatibles avec les traces arrière. Par exemple, certains builds peuvent
supprimez la sortie du processus
debuggerdà l'aide deprctl(PR_SET_DUMPABLE, 0)Pour en savoir plus, consultezdebuggerd - Le niveau d'API 19 n'est actuellement pas pris en charge en raison d'erreurs d'autorisation de fichier.