Tests de téléphonie ACTS

La suite de tests Android Comms (ACTS) effectue des tests automatisés des piles de connectivité, telles que les services Wi-Fi, Bluetooth et cellulaires. L'outil de test nécessite adb . et Python, et il peut être trouvé dans tools/test/connectivity/acts .

Cette page décrit comment exécuter les tests de téléphonie de base disponibles dans le projet Android Open Source (AOSP) pour un utilisateur disposant de deux téléphones.

Conditions préalables

Pour exécuter des tests de téléphonie ACTS, vous devez avoir accès à un référentiel Android complet et installer les versions userdebug sur les appareils que vous souhaitez tester.

Télécharger un référentiel Android

Suivez les instructions dans Téléchargement de la source pour télécharger un référentiel Android sur une machine disposant d'une connexion USB aux appareils que vous souhaitez tester.

• AOSP est une base de code de plusieurs gigaoctets qui continue de croître. Ajustez vos attentes en matière de temps de téléchargement en conséquence.
  • Si une machine est limitée en taille, ajoutez --depth=1 à la commande repo init .
• Pour obtenir les futures mises à jour des outils ACTS, accédez au répertoire racine Android :
  • Utiliser repo sync tools/test/connectivity
  • Et repo sync external/sl4a

Vérification des builds userdebug sur les appareils

Installez une version userdebug d'Android sur vos appareils de test.

• Créez le référentiel en suivant les instructions de Building Android .
• Flashez l'appareil comme décrit dans Flasher un appareil .
  • La commande adb shell getprop ro.build.type doit renvoyer userdebug .
  • Si ro.build.type n'est pas disponible, une version userdebug permet d'exécuter le shell adb en tant que root (terminal # ).

Construire et installer SL4A

Pour créer et installer Scripting Layer pour Android (SL4A), suivez les instructions de Scripting Layer pour Android . La section Ajout de builds SL4A aux builds Android par défaut est facultative.

Après avoir construit SLA4, le dernier message du journal contient l'emplacement du fichier sl4a.apk , que vous devez installer sur TOUS les appareils. Voici un exemple de message de journal :

Copy: out/target/path/to/sl4a.apk

Remarque : Créez différentes instances sl4a.apk pour chaque type d'appareil testé (DUT).

Remarque : Pour une stabilité maximale, créez sl4a.apk à partir du même référentiel et de la même version que ceux à partir desquels le DUT a été flashé. Les messages d'erreur qui incluent le texte Erreur dans RPC indiquent une probable incompatibilité entre SL4A et le système d'exploitation.

Configuration des appareils à tester

Configurez les appareils à l'aide de ces exigences de build/outil ACTS :

• Si les clés du fournisseur ADB ne sont pas disponibles, appuyez sur la fenêtre contextuelle Faire confiance à cet ordinateur sur le DUT lorsqu'elle apparaît. Si les clés du fournisseur ADB sont disponibles :

  • Les clés et pilotes du fournisseur ADB doivent être uniques au DUT.
  • Pour toujours activer le débogage USB, les clés du fournisseur ADB dans votre arborescence source doivent être ajoutées à ~/.bashrc (ou équivalent) à l'aide export ADB_VENDOR_KEYS=/path/to/directory/with/vendor/keys où /path/to/directory est votre chemin pleinement qualifié sur l’hôte. Pour dépanner ADB, reportez-vous à Exécuter des applications sur un périphérique matériel .

• Autoriser le débogage USB : lorsque les pilotes adb sont installés, les périphériques adb peuvent déclencher une invite sur le périphérique pour autoriser le débogage USB.

• Installez sl4a.apk en utilisant $ adb install -r <ANDROID_ROOT>/path/to/sl4a.apk

• Assurez-vous que les téléphones utilisent une connexion USB 2.0 au serveur de test.

• Ces tests dépendent des réseaux cellulaires actifs, alors insérez des cartes SIM dans les téléphones et conservez les téléphones dans une zone disposant d'un bon service cellulaire.

• Ajoutez toutes les cartes SIM à un fichier .json comme décrit dans Écriture d'un fichier de configuration .

Mise en place de l'environnement

Avant de configurer l'environnement, vérifiez que Python 3.4+ est installé .

Courir:

sudo apt-get install python3-setuptools
sudo apt-get install python3-pip
sudo pip3 install --upgrade pip setuptools
sudo apt-get install protobuf-compiler

Installation d'ACTS

Courir:

cd <ANDROID_ROOT>/tools/test/connectivity/acts/framework/
sudo python3 setup.py develop
cd -

Pour vérifier l'installation, exécutez act.py -h , qui imprime une liste des commandes disponibles.

Écrire un fichier de configuration

Pour exécuter des tests, vous devez créer un fichier avec les informations de configuration. Voici un exemple de fichier .config . Un fichier similaire est disponible dans le référentiel Android sous tools/test/connectivity/acts/framework/sample_config.json . Remplacez XXXXXXX par les numéros de série des appareils pour fournir les informations minimales dont ACTS a besoin pour exécuter un test de téléphonie.

{
  "_description": "Minimum Telephony Config",
  "testbed":
  [
      {
          "_description": "A testbed listing two AndroidDevices for adb.",
          "name": "ExampleTestBed",
          "AndroidDevice": [{"serial": "XXXXXXX", "adb_logcat_param": "-b all"},
                            {"serial": "XXXXXXX", "adb_logcat_param": "-b all"}]
      }
  ],
  "logpath": "/path/to/logs",
  "testpaths": "/path/to/android/repo/tools/test/connectivity",
  "sim_conf_file": "/path/to/simcard_list.json"
}

Utilisez les touches du tableau pour configurer les paramètres de test. Reportez-vous à Options de configuration supplémentaires pour plus d'options.

Clé	Valeur
_description	Commentez le contenu de l'intégralité du fichier de configuration
testbed	Spécification d'un environnement dans lequel les tests peuvent s'exécuter
(banc d'essai) _description	Commentez chaque banc d'essai, car ACTS peut cibler des bancs d'essai individuels
(banc d'essai) name	Nom du banc de test pour l'appel depuis la ligne de commande
(banc d'essai) AndroidDevice	Liste des appareils spécifiques ciblés par le test Remarque : Plusieurs appareils peuvent être répertoriés. Un test qui exécute des appels téléphoniques s'attend à ce qu'il y ait deux appareils et échoue s'il y en a moins. Si deux appareils sont répertoriés et que le test n’en attend qu’un, ce test est exécuté sur le premier appareil.
(banc d'essai)(AndroidDevice) serial	Numéro de série de l'appareil (imprimé à partir adb devices )
(banc d'essai)(AndroidDevice) adb_logcat_param	Paramètres transmis lorsque adb logcat est appelé pendant les tests
logpath	L'emplacement sur le serveur de test où les journaux sont enregistrés
testpaths	L'emplacement du code du scénario de test
sim_conf_file	L'emplacement du fichier .json qui répertorie les cartes SIM disponibles La liste des cartes SIM comprend l'identifiant de la carte, les capacités de la carte, l'opérateur et le numéro de téléphone.

Remarque : Vous pouvez donner n'importe quel nom au fichier défini sur sim_conf_file , à condition qu'il soit au format JSON. Il s'agit d'une solution de secours dans les cas où les opérateurs de téléphonie mobile n'autorisent pas l'interrogation du numéro de téléphone à l'aide des API Android. Voici un exemple.

{
    "sim-card-ID-here": {
        "capability": [
            "voice",
            "ims",
            "volte",
            "vt",
            "sms",
            "tethering",
            "data"
        ],
        "operator": "tmo",
        "phone_num": "12345678901"
    },
...
}

Vous pouvez extraire le numéro de téléphone de l'appareil sous Système > À propos du téléphone . L'ID de la carte SIM est généralement imprimé sur la carte SIM ou est disponible sur l'appareil sous Système > À propos du téléphone > État de la carte SIM . La chaîne d'opérateur est définie dans tools/test/connectivity/acts_tests/acts_contrib/test_utils/tel/tel_defines.py , puis recherchez CARRIER_ .

Options de configuration supplémentaires

Le fichier entries.py situé dans tools/test/connectivity/acts/framework/acts/config/entries.py dans le référentiel Android contient des définitions pour les principales options de configuration de ligne de commande.

Vous pouvez également trouver des paramètres spécifiques aux tests dans le code en recherchant self.user_params.get .

Exécution de tests

Exécutez des tests à partir de la ligne de commande une fois le fichier de configuration écrit. Bien qu'il existe de nombreuses options, la plus simple consiste à utiliser -c filename.config -tc TestCase:name . Cet exemple utilise un fichier de configuration nommé minimum.config :

act.py -c minimum.config -tc TelLiveVoiceTest:test_call_mo_voice_general

Remarque : sur -tc ci-dessus, TelLiveVoiceTest est un fichier de test et :test_call_mo_voice_general est un scénario de test spécifique dans ce fichier. Pour exécuter tous les tests du fichier, appelez uniquement -tc TelLiveVoiceTest . TelLiveVoiceTest contient de nombreux cas de test de longue durée, il est déconseillé d'exécuter tous les tests du fichier.

Un test réussi devrait avoir un message de sortie final comme celui-ci :

INFO Summary for test run ExampleTestBed@yyyy-mm-dd_15-23-43-614: Requested 1,
Executed 1, Passed 1, Failed 0, Skipped 0, Error 0

Exécuter plusieurs tests

Pour exécuter des cas de test spécifiques sur plusieurs fichiers, créez un fichier de test et transmettez-le avec l'indicateur -tf , comme indiqué dans l'exemple de suite de tests de régression ci-dessous.

TelLiveVoiceTest:
test_call_mo_voice_general,
test_call_volte_to_volte,
test_call_3g_to_3g

TelLiveDataTest:
test_airplane_mode,
test_4g,
test_3g

TelLiveSmsTest:
test_sms_mo_4g,
test_sms_mt_4g,
test_sms_mo_3g,
test_sms_mt_3g,
test_mms_mo_4g,
test_mms_mt_4g

Cet exemple de commande suppose que le fichier s'appelle regression_suite.

act.py -c minimum.config -tf regression_suite

Exécuter des tests plusieurs fois

Pour exécuter un scénario de test ( -tc ) ou un fichier de test ( -tf ) plusieurs fois, ajoutez -ti # (itérations de test) à la commande.