Embed Size (px)
Citation preview
Manuel Utilisateur RobotSaisie V4.5.3
RobotSaisie
V4.5.3
Manuel Utilisateur
Le présent document contient des informations qui sont la propriété de Jean-Louis PASTUREL. L'acceptation de cedocument et du logiciel associé par son destinataire implique, de la part de ce dernier, l'engagement de n'en faireaucune reproduction, aucune transmission à des tiers, aucune divulgation et aucune utilisation commerciale sansl'accord préalable de Jean-Louis PASTUREL.
Le document et le logiciel associé sont livrés dans l'état. L'auteur décline toute responsabilité liée à un mauvaisfonctionnement du logiciel. L'utilisateur utilise ce logiciel à ses risques et périls.
Description Des Versions Successives
VERSION DATES ETAT DE LA MISE A JOUR REDACTEUR(S)
V1.0 01/01/04 Initialisation pour RobotSaisie V4.5 JL PASTUREL
V1.1 06/02/04 Modification pour fonctonnalitésnouvelles 4.5.1
JL PASTUREL
V1.2 10/02/04 Ajout contrôle par photo écran pendantla phase de connexion
JL PASTUREL
V1.3 15/03/04 Portage sur Linux avec limitations surcontrôles curseursRobotSaisie Version 4.5.3.Installation automatiqueOutil swing de paramétrage
JL PASTUREL
V1.4 15/02/05 Correction bugs RobotCapture . Mise àjour du manuel utilisateur ( précisionparamètres de lancement =>introduction de RobotTimer)
JL PASTUREL
V1.5 15/04/05 Intégration des différents outils dans unworkbench unique
JL PASTUREL
Table des matières
INSTALLATION.................................................................................................................................51) Packaging du logiciel..................................................................................................................52) Préparation pour l'installation......................................................................................................53) Installation...................................................................................................................................54) Lancement du test du clavier.......................................................................................................75) Paramétrages................................................................................................................................9
Paramétrage du clavier sous Windows NTx...............................................................................9Paramétrage du clavier sous Linux...........................................................................................11Outil de paramétrage pour RobotSaisieV4.proporties , RobotCaptureW.proporties etRobotCaptureL.properties.........................................................................................................12
MANUEL UTILISATEUR RobotSaisie............................................................................................17BUT DE L'OUTIL.........................................................................................................................17
Ce que fait l'outil.......................................................................................................................17Ce que ne fait pas l'outil............................................................................................................17Les différents composants du logiciel.......................................................................................18
L'APPLICATION A SERVIR.......................................................................................................20Les pré-requis............................................................................................................................20La méthode par l'exemple.........................................................................................................20Le paramétrage du fichier des données à saisir dans des champs ou zone texte.......................23Gestion de la souris et de la molette.........................................................................................26Exemple de paramétrage sur mon PC. Fichier essai1.properties..............................................27Paramétrage fichier essai1.cnx..................................................................................................28Paramétrage fichier essai1.dcx..................................................................................................30L' arborescence de ce scénario..................................................................................................30Lancement de l'application et de RobotSaisie V453.................................................................31
GENERALISATION.....................................................................................................................33Les étapes clés pour simuler la saisie dans une application......................................................33
MANUEL UTILISATEUR................................................................................................................34 Enregistrer des scénarios...................................................................................................................34
But de l'outil...................................................................................................................................34Résultats fournis par l'outil............................................................................................................34Exemple d'utilisation.....................................................................................................................35
Fichier de paramétrage de l'outil pour les captures .................................................................35Pré-requis au lancement de l'outil..................................................................................................35
Lancement de l'outil..................................................................................................................36Fonctionnement avec contrôles Souris..........................................................................................38Pour info : fonctionnement avec contrôles claviers ( sous Windows seulement)..........................46Evolution de la saisie des checkpoints à partir de la version 4.5.3................................................53
Menu OUTIL / Position Clic Souris...................................................................................................55
But de cet outil...............................................................................................................................55Principe d'utilisation......................................................................................................................55Lancement......................................................................................................................................55.......................................................................................................................................................56Mode Opératoire............................................................................................................................56
Utilisations avancées de RobotSaisie.................................................................................................58Cas particulier à couvrir des lignes de données à nombres de colonnes variables........................58Les solutions possibles..................................................................................................................58La solution des données et contrôles contextuels..........................................................................58Syntaxe des données et contrôles contextuels dans le fichier .csv................................................59
ASTUCES..........................................................................................................................................60Contrôles NULL............................................................................................................................60Rajout d'un contrôle.......................................................................................................................60
Utilisations Diverses de RobotSaisie..................................................................................................62Présentation....................................................................................................................................62Tableau des valeurs possibles et comportement de RobotSaisie...................................................62Le fichier timerScénario.properties...............................................................................................64Arrêt forcé du scenario..................................................................................................................65La génération des traces XML.......................................................................................................66
LISTE DES PERFORMANCES DISPONIBLES..............................................................................70PERFORMANCE DU SCENARIO : essai3......................................................................................70ANNEXE 1 : clavier_FR.properties ( Exemple)................................................................................73ANNEXE 2 : RobotCaptureW.properties (Exemple).........................................................................76ANNEXE 3 : Aide-Mémoire..............................................................................................................78AIDE-MÉMOIRE UTILISATION ROBOT-SAISIE........................................................................78
Mécanisme général........................................................................................................................78Lancement de RobotSaisie.............................................................................................................79
INSTALLATION
1) Packaging du logicielLe logiciel se présente sous la forme d'un package java jar : RobotSaisieV453.jar.
Cette version intègre un portage presque complet sur Linux => Le contrôle de la forme du curseurn'est pas traitée car à priori c'est impossible en X11, l'attribut Cursor n'est pas consultable. On devrautiliser comme contournement, des images d'écrans ou portions d'écran significatives plusnombreuses
2) Préparation pour l'installation
Avoir installé un JDK java 1.4.x ; à récupérer sur le site de sun : http://java.sun.com/
L'installer sous le répertoire (par exemple) : c:\jdk142
L'installeur automatique détecte le type d'Opérating Systeme sur lequel se fait l'installation ( Linuxou Windows)
Les exemples de chemin donnés ci-dessous le sont pour Windows. L'unixien adaptera pour Linux.
Créer le répertoire de base (par exemple) c:\util\RobotSaisieV453
Créer le répertoire de travail ( accueil des scénarios. par exemple ) : c:\util\workspace
Vérifier que le PATH du système pointe aussi sur c:\jdk142\bin . Sinon compléter le PATH par les
outils d'administrations livrés avec votre Windows préféré.
3) Installation
3.1)Mettre le fichier archive RobotSaisieV453.jar sous le répertoire : c:\util\RobotSaisieV453
3.2)Ouvrir une fenêtre de commande, et se positionner sous le répertoire c:\util\RobotSaisieV453
3.3)Lancer la commande :
java -classpath .\RobotSaisieV453.jar RobotSaisieJLPV4.Install
Veillez à respecter la casse ( minuscule / majuscule) lors du lancement de la commande.L'écran suivant apparaît :
L'écran est semblable sous Linux
Remplir les champs :
– Répertoire Installation Base avec le nom du répertoire courant . Pour notre exemple :
c:\util\RobotSaisieV453. Le logiciel gère les noms de répertoire avec des espaces.
– Répertoire travail workspace avec un nom de répertoire de travail qui doit exister ( on peut
aussi prendre le même répertoire que ci dessus mais ce n'est pas conseillé).Pour notre exemple
c:\util\workspace
– Répertoire du jdk_home : Emplacement du jdk. Pour notre exemple c:\jdk142
– Chemin complet pour le lancement du navigateur HTML.
Et cliquer sur Accepte, l'installeur vous avertit de la réussite ou de l'échec de l'installation.
Le logiciel d'installation crée tous les lanceurs nécessaires au produit.
4) Lancement du test du clavier
Ce test permet de vérifier que les touches claviers seront correctement générées.Suivre la procédure suivante :
Créer un répertoire Test sous le répertoire de travail %workspace%
Lancer un éditeur de texte type notepad ou wordpad.
Sous une fenêtre de commande, aller sous le répertoire c:\util\RobotSaisieV453
Lancer la commande : .\RobotWindowW.bat
Choisir les menus suivants :
Cliquer sur Lancer et basculer sur l'éditeur de texte lancé précédemment.
Vous avez dix secondes pour vous repositionner sur l'éditeur de texte. Assurez-vous que l'éditeur ale focus. Attendre et vérifier que le texte affiché dans l'éditeur est correct. En fin de test supprimer lerépertoire Test sous le répertoire %workspace%
Si pas correct, voir les paragraphes suivants pour paramétrer le fichier clavier_FR.properties..
Le test décrit ici ne valide que les touches des caractères visibles. Pour valider les touches decontrôle et les touches de fonctions, il faut exécuter la procédure décrites dans les écrans ci-dessous :
Exemple : un appui sur F1 donne son code : 112
5) Paramétrages
Paramétrage du clavier sous Windows NTxNota :
Vous n'avez pas à re-paramétrer le clavier si vous travaillez sous Windows et clavier
AZERTY.
Le paramétrage proposé correspond à un clavier AZERTY 105 touches.
Il faut noter les touches qui sont incorrectement générées lors du test précédent.
Dans cette opération, en éditant le fichier clavier_FR.properties, on vérifie aussi par la même
procédure que les touches de contrôle et de fonction ont leur keyCode et modificateur corrects. Le but de la manipulation ci-dessous est de récupérer le keyCode de la touche et son modificateur( aucun, shift, alt, alt_graph ou alt_control).
Le Fichier clavier_FR.properties est visualisable par l'enchaînement d'écrans suivants :
On peut, comme indiqué en haut de l'écran rajouter des contrôles non encore existant. On peuttrouver la valeur des touches en utilisant le mécanisme décrit plus haut. Avant d'effectuer ces
manipulations prendre la précaution de faire une sauvegarde de clavier_FR.properties.
Après avoir noté toutes les touches, mettre à jour le fichier clavier_FR.properties à l'aide des
écrans ci-dessus.
En-tête du fichier clavier_FR.properties ( sous %base%) :
# Application RobotSaisie. Fichier de parametrage du clavier# Ce fichier de properties decrit les keycodes des touche claviers# en dehors des touches correspondant a la codification ASCII# les touches qui correspondent a la numerotation ascii sont :# [A-Z] , [0-9], [a-z]## Pour parametrer le clavier : utiliser le programe KeyEventDemo issu de SUNmodifie# en application : java KeyEventDemo.#Chaque ligne a la structure ci-dessous#<NOM_TOUCHE>=<KEYCODE>_<MODIFICATEUR>#Les modificateurs sont#pas de modificateur => 0#SHIFT => 1#ALT_GRAPH => 10 ( A voir avec Windows => peut etre aussi ALT + CONTROL)#ALT+CONTROL => 2 ( A voir avec Windows => peut etre aussi ALT_GRAPH)#CONTROL => 3#ALT => 4#
ESPACE=32_0AMPERSAND=49_0E_AIGU=50_0DOUBLE_QUOTE=51_0SIMPLE_QUOTE=52_0PARENTHESE_GAUCHE=53_0MOINS=54_0...
Paramétrage du clavier sous Linux
La gestion de l'enregistrement des touches claviers et clic de souris est sensiblement différent sousLinux par rapport à Windows. Par contre la simulation des touches et clic souris est la même àtravers la classe Java java.awt.Robot . Merci Sun !
Le workbench propose une lecture de ce fichier, mais ne permet pas de le modifier. Il faudra doncappliquer la méthode décrite ci-dessous pour modifier éventuellemnr ce mapping touche clavier /numéro de touche X11.Il faut donc introduire un fichier de paramétrage supplémentaire de mapping de clavier sous Linux.
Il s'appelle keymap.csv et est situé sous $base pour unix)
Il est fournit un fichier keymap.csv correspondant à un clavier 105 touches AZERTY. Si votreclavier est le même, vous ne devriez pas à avoir à faire la configuration décrite ci-dessous.
Avant de lancer la configuration, faire une sauvegarde du fichier keymap.csv.Ce fichier est constitué de 256 lignes de numérotée de 0 à 255 et dont la syntaxe est :<num_ligne><Espace><codeTouche>ex :19 48
Pour déterminer ce qu'il faut mettre dans les deux colonnes du fichier il faut lancer deux utilitaires :
– l'utilitaire lanceKeyL.ksh ( voir écran un peu plus haut)
– l'utilitaire linuxjlp sous une console xterm, dans le répertoire d'installation.
Le clavier doit être positionné avec le verrouillage numérique actif et la touche des majusculesdéverrouillée.
Pour chaque touche appuyée, on repère la première colonne du fichier keymap.csv par le retour de
l'utilitaire linuxjlp ( dernier nombre de la ligne de retour) et on met en face le code renvoyé par
l'utilitaire lanceKeyL.ksh.
Certaines touches n'ont pas de code dans lanceKeyL.ksh, on met alors en face le code ASCII ducaractère correspondant à l'état du clavier ( majuscule non actif et verrouillage numérique actif).Pour notre exemple plus haut :19 48 pour le retour 19 du programme linuxjlp correspond à l'appui prolongé sur la touche à/0 /@ ( 0 a lecode ASCII 48)
Outil de paramétrage pour RobotSaisieV4.proporties ,
RobotCaptureW.proporties et RobotCaptureL.properties
Avant toute manipulation des fichiers, faire une sauvegarde des fichiers suivants :– RobotSaisieV4.properties ( Windows et Linux)– RobotCaptureL.properties ( Linux)– RobotCaptureW.properties ( Windows)
Ces fichiers sont situés sous %base% ( $base sous Linux)
Pour paramétrer ces fichiers, il faut lancer l'enchaînement d'écran suivant ( apres avoir lancéRobotWindowW.bat ou RobotWindowL.ksh).
Ce qui correspond au paramétrage du fichier RobotSaisieV4.properties.
Ce qui correspond au paramétrage du fichier RobotCaptureW.properties (resp :
RobotCaptureL.properties).
Le fait d'appuyer sur enregistrer sur un ou l'autre onglet, lance la mise à jour des trois fichiers de
paramétrage ( RobotSaisieV4.properties, RobotCaptureW.properties et clavier_FR.properties respRobotCaptureL.properties sous Linux).
Pour Linux un onglet supplémentaire ( en lecture seule) permet de visualiser le contenu du fichierkeymap.csv
Ci-dessous un exemple du fichier RobotSaisieV4.properties
autoDelay=20ficTest=ficTest.txt# Caractere d arret# defaut ESCAPE#escape=ESCAPEescape=F8# Sleep des thread myThread ( thead principal d ecriture)# et mySpyThread ( Thead d attente d une interruption a l aide de la touche
definie# par le parametre escape ci-dessus).Valeur pour CPU >=1,5 GHz A augmenter siCPU plus faiblesleepMyThread=100sleepMySpyThread=100
# keyBoucle est la periode d auscultation de modification des touches clavierset# des clics de souris. A adapter en fonction de la puissnce de l ordinateur. Aaugmenter si frequence faible# valeur 20 ms pour CPU >= 1,5GhzkeyBoucle=20
#validation du claviertest=false
# Boucle d attente pour valider une image ou l attente d un curseurnbBoucleCheck=2tempoInitBoucleCheck=1000multiplicateurTempoCheck=3
# Pour automatiser la recherche des handle des curseurs# Le parametre FORCE_CURSOR doit être a NO pour WINDOWS# Pour LINUX le mettre à YESFORCE_CURSOR=NO
# Dans le cas ou FORCE_CURSOR est a YES les lignes ci-dessous seront prises encompte# et il convient de mettre les bonnes valeurs aux curseurs correspondant# On connait la ressource du curseur ( Windows uniquement) sinon on met a NONE# Pour trouver si la ressource curseur de l'application :# 1) lancer l'application# 2) lancer l'utilitaire testCurseur.exe# 3) Positionner la valeur renvoyée par la variable hcurseur a ARROW# 4) postionner de meme la variable de curseur texte, hand, sablier etarrow_sablier# #WIN NT#ARROW=65544#TEXTE=65545#HAND=0#SABLIER=0#ARROW_SABLIER
#WINXP#ARROW=#TEXTE=65555
#WIN 95#ARROW=5374#TEXTE=5366
#WIN 2K/win XP#ARROW=65553#ARROW_SABLIER=65575#TEXTE=65555#HAND=65581#SABLIER=65557
#LINUX Pour utilisation du logiciel sous LINUX => FORCE_CURSOR doit etre a YESARROW=0
TEXTE=0HAND=0SABLIER=10000ARROW_SABLIER=10000#
clavier=clavier_FR.properties
# on est sur un syteme Windows et paradoxalement il faut laisser # windows a true même sous Linux !windows=true
#On fait du copie and paste ou de la saisi cararctere par caracterecopyAndPaste=false
# parcage de la souris pour prendre image de controleparcMouseX=150parcMouseY=300
#PourMilli\u00E8me de pixel differents max pour une egalite image 0=> Tous lespixels sont \u00E9gaux ; 10 => 1% des pixels sont differents mais l'image seraconsid\u00E9r\u00E9 comme identiquetolerance=1
formatImage=png
#Nombre de boucles de tests en mode mesure ( boucleInfini != false)nbBouclesMesure=10
#Tempo entre chaque boucle ( voir nbBouclesMesure)tempoMesure=500
Ce fichier doit pouvoir être utilisé dans l'état. On ne le modifiera qu'après avoir bien pris l'outil enmain. Pour plus de sécurité, il est conseillé de faire une sauvegarde de ce fichier original avant toutemodification.
MANUEL UTILISATEUR RobotSaisie
BUT DE L'OUTILCet outil peut être utilisé par des personnes chargées d'initialiser des applications à partir d'IHM oubien par les intégrateurs pour faire des tests de non régression. On peut utiliser l'outil, pour mesurerdes temps de transaction ( si possible non destructive => consultation) vu de l'utilisateur.
On peut aussi programmer des exécutions de scénario par un mécanisme similaire au cron UNIX.
Ce que fait l'outil
L'outil simule un utilisateur humain, tapant des touches au clavier et/ou des clics de souris. L'ordre
des touches, les actions de la souris ainsi que les pauses nécessaires sont programmables etparamétrables.
L'IHM peut être à base de pages HTML, d'applets java, de formulaire html / javascript, d'IHM enC/C++, d'éditeur de textes.
Les objets de l'IHM gérés sont les curseurs ( cas de Windows pas possible sous Linux) et lesphotos d'écrans :
curseurs ( flèche, sablier, main, flèche et curseur, barre verticale d 'éditeur), les curseurssablier, flèche et sablier provoquent des boucles d'attentes jusqu'à l'arrivée d'un curseurvalide . On sort de la boucle au bout d'un certain nombres de boucles paramétrables. L'arrêtdéfinitif de l'application est géré par les comparaisons d'écrans. Toutes les applicationsn'utilisent pas correctement les curseurs. Rappel ce mécanisme est impossible sous Linux.
Photos d'écran : on place des points de contrôles dans les scénarios, pour vérifier que l'onpasse par ces points. Ce contrôle est complémentaire ( et obligatoire) du contrôle descurseurs. Une mauvaise comparaison d'image arrête la saisie.
Ce que ne fait pas l'outil
Comme sur un poste client, on ne peut faire tourner qu'une instance de cet outil, il n'est pas
prévu pour faire des mesures de performance de l'application ou dans des cas limités
d'application avec peu d'utilisateurs de test de charge ( exemple potentiel 50 utilisateurs que
l'on peut bencher au 1/10 ieme => 5 postes)
L'outil ne gère pas le contexte fonctionnel, ni les objets propres windows utilisés par l'IHM ( Voirpour cela des outils professionnels de Mercury ou autres éditeurs). La seule possibilité en cas de
problème détecté sur image non conforme au modèle est l'arrêt du scénario.
Nota : Bien qu'écrit en Java, l'outil fait en partie appel au mécanisme JNI ( Java Native Interface)
qui est lié à l'OS, l'outil livré supporte Windows NT4, NT 2000, NT XP, Linux . Cette version n'apas été testée sous W9x, mais il est possible qu'il y ait des problèmes dûs à ces bibliothèques JNIdll.
Les différents composants du logiciel
L'outil se compose s'articule autour d'un workbench qui permet d'exécuter :– de la configuration ( vu plus haut)– des enregistrements de scénarios– des excécutions de scénarios sous 3 formes .– l'analyse des traces d'exécutions ( logs et performances sous pages HTML)– 2 outils Le workbench se lance par la commande :
- RobotSaisieWindowW.bat pour Windows
- RobotSaisieWindowL.ksh pour Linux
Le menu d'éxécution des scénario ( Classe Java : RobotSaisie) est l'outil qui permet de simuler les
frappes claviers et clics souris issus d'un scénario.
Il permet de simuler : • la phase de connexion à l'application • la saisie de 1 à n boucles de données à partir d'un fichier au format csv ( lignes de champsséparés par des ; ) • la phase de déconnexion L'ensemble de ces trois phases et des données à saisir constitue un scénario.
Deux menus du workbench ( classes Java RobotCaptureW , RobotRecordW resp
RobotCaptureL et RobotRecordL) permettent d'enregistrer le scénario modèle qui pourra être
ensuite rejoué par RobotSaisie . L'enregistrement se fait directement dans l'application.
Pour l'utilisation de l'enregistrement à l'aide de la bascule clavier, il y a deux touches àprogrammer :
• la première pour basculer de l'application à enregistrer vers RobotCaptureW ( resp
RobotCaptureL pour Linux) pour passer des phases de connexions, à la phase de boucle et de la
phase de boucle à la phase de déconnexion. (identifiée CAR_BASCULE=ALT_F9 dans le fichier
RobotCaptureW.properties/RobotCaptureL.properties )
• La deuxième permet d'introduire des points de contrôles, ( copie d'écran) qui permettent par la
suite à RobotSaisie de contrôler le bon déroulement des boucles de saisie.(identifiée
CAR_CONTROLE=F9 dans le fichier RobotCaptureW.properties /
RobotCaptureL.properties )
Pour ce qui concerne l'enregistrement par bascule souris, il faut déplacer la souris dans le coin hautgauche ce qui fait apparitre une fenetre avec 2 boutons ( 1 pour changer de phase, et l'autre pourprendre des copies d'écrans). Je conseillerai cette deuxième façon de travailler.
Lors de l'enregistrement les fichiers de connexions, boucles et déconnexions sont générés, ainsiqu'un fichier de données de 1 ligne au format csv qui servira de modèle pour créer un fichiercomportant plusieurs lignes de données.
Pour la présentation, nous allons ( même si ce n'est pas la logique d'utilisation) présenter d'abord
l'utilisation des classes RobotSaisie puis RobotCaptureW.
L'APPLICATION A SERVIR
Les pré-requis
L'application peut avoir indifféremment une IHM de type saisie au clavier et/ou utilisation de lasouris.
RobotSaisie est capable d'automatiser des saisies répétitives d'entrées de données dans des
formulaires et écrans éditables de l'application. Le fonctionnement de cet outil est sécurisé, par un mécanisme de prise de cliché à des points clés etdes attentes de handle de curseur dans le cas d'une utilisation sous Windows. Il faut veiller aussi que le Robot ait toujours le focus sur l'interface de l'application. Il faut doncéliminer toute les applications qui peuvent envoyer des pop-up ou qui risquent de prendre le focusde l'écran au Robot.
Arrêter donc mail, scheduler, écrans de veille ...quand vous utilisez RobotSaisie.
La méthode par l'exemple
Pour faire simple, nous allons partir d'un exemple simple d'une application qui a un IHM qui est unformulaire HTML, comportant des zones de saisies, et des boutons de submit.Une page HTML sera affichée prouvant la saisie, et on re-bouclera sur la première en rentrantplusieurs lignes .
Le mécanisme de programmation de la classe RobotSaisie s'appuie sur quatre fichiers.
un fichier de type csv, dans lequel on stocke les caractères visibles à saisir dans les objets de
l'interface un fichier des touches de contrôles qui permettent de passer d'un champ à l'autre, de valider lessaisies...
Le fichier essai.properties:
• un paramètre autoDelay pour donner le temps d'attente entre chaque touche( => gérer la
vitesse de frappe). Cette valeur dans supplante la valeur autoDelay du fichier
RobotSaisieV4.properties.
• un paramètre freqLog pour définir la fréquence de traçe par rapport aux lignes du fichier .csv.
• Pour chaque saut de colonne (i=>i+1) rajout d'un ou plusieurs checkpoints chp_pt_col{i}_
{i+1}
• Un paramètre tolerance en pour-mille permettant de définir la tolérance d'écart de deux
images comparées pixel par pixel.
On lance l'interface (IHM) de l'application à saisir et de se déconnecter en fin de saisie. Deuxfichiers sont nécessaires :
un fichier à l'extension .cnx décrivant l'enchaînement de connexion
un fichier avec l'extension .dcx décrivant l'enchaînement de déconnexion.
A noter que les extensions .cnx .csv .dcx .properties sont obligatoires.
L'arborescence des fichiers est imposé dans cette version 45x de RobotSaisie comme indiqué ci-dessous pour Windows :
• %workspace%\<scenario>\<scenario>.properties
• %workspace%\<scenario>\<scenario>.csv
• %workspace%\<scenario>\<scenario>.cnx
• %workspace%\<scenario>\<scenario>.dcx
• %workspace%\<scenario>\log\
• %workspace%\<scenario>\imgcheck\
• %workspace%\<scenario>\imgerr\
L'outil workbench génére les arborescences correctement lors de l'enregistrement des scénarios. Ces quatre fichiers sont donc directement liés à l'application que l'on veut alimenter. C'est àl'utilisateur de les préparer.
Il existe une classe spécifique pour l'enregistrement outil spécifique pour Windows
RobotCaptureW.bat et RobotCaptureL.ksh pour Linux. Mais cette complexité est cachée par
le workbench. Ce dernier permet d'enregistrer directement dans l'application ( il est muni d'unKeyLogger qui espionne les touches claviers frappée et permet aussi d'enregistrer des clics souris)
Le fichier .cvs de données de masse est à créer à l'aide d'outil type excel, StarOffice, OpenOffice ouautre logiciel éditeur permettant de gérer le format csv. L'outil impose de donner le même préfixe au nom des 4 fichiers ( exemple essai.csv,essai.properties, essai.cnx et essai.dcx).
L''intérêt du format csv, c'est que l'on peut préparer le fichier qui contient les données à rentrer sous
Excel par exemple, pour permettre des copies de lignes en grand nombre. La sauvegarde se fera
ensuite au format csv. Le séparateur par défaut est le point-virgule mais on peut paramétrer un
autre séparateur dans le fichier RobotSaisieV4.properties en modifiant le paramètre sep. On
veillera toujours que les données à saisir ne contienne pas le séparateur. L'outil ne sait pas
gérer les retours à la lignes dans les données de saisies.
Pour notre exemple, nous allons créer une application minimale dont l'interface est un formulairedans une page HTML, avec des zones de saisie et des boutons de contrôles. Nous y introduirons lagestion de la souris Une autre page HTML assurera de la bonne saisie des champs et on re-bouclerasur la première page tant qu'il y aura des lignes dans le fichier .csv.
Le formulaire HTML
Le fichier s'appelle essai1.html. Ci dessous une copie de l'écran
Ci dessous l'écran de validation de la prise en compte et qui permet de revenir sur le premier quandon clique sur submit. Le fichier s'appelle essai2.html.
Le paramétrage du fichier des données à saisir dans des champs ou zone texte.Fichier essai.csv. La copie de l'écran 1 fait apparaître 13 zones de saisies de caractères visibles.
Donc ce fichier sera constitués de lignes comportant chacune 13 champs séparés par des ;. On peutchoisir un autreOn peut préparer cela à travers un tableur type Excel. Voir ci dessous une copie d'écran.
Le fichier enregistré au format csv a alors le format ci-dessous :
Salade;2;3;6;Tomate;15;8;120;Vin;10;10;100;226
Celeri;2;3;6;Haricot;15;8;120;Biere;10;10;100;226
Pommes;2;3;6;Poireau;15;8;120;Eau;10;10;100;226
Navet;2;3;6;Oignons;15;8;120;Cidre;10;10;100;226
L'enregistrement d'un scenario, à laide de la bascule souris se réalise ( que l'on soit sous Windowsou sous Linux) directement à partir du Workbench que nous verrons plus loin.
Le lancement du scénario aussi bien sous Windows que sous Linux se fait à l'aide de l'enchaînementd'écrans suivant :
Le fichier essai.properties non paramétré est le suivant en tenant compte des 13 données de
l'exemple à rentrer par ligne :
Le paramètre autoDelay donne un délai automatique de 20 milli-secondes.
• un paramètre freqLog pour définir la fréquence de trace par rapport aux lignes du fichier .csv.
• Pour chaque saut de colonne (i=>i+1) rajout d'un ou plusieurs checkpoints chkp_pt_col{i}_
{i+1}.
Un exemple de syntaxe du checkpoint est la suivante: Sur la ligne coli_{i+1}=MOV584_553,300,CLKG_0,1481,|MOV541_615,300,CLKG_0,2700,MOV78_367,300,CLKG_0,1075,|NULL,300 apparaissent le cas échéant des barres verticales ( pipe : | ) avnt certain contrôle. Dans notre cas il y
en a 2. la ligne chkp_pt_col{i}_{i+1} en dessous a cette forme
%70_%70,X12Y13_X1000Y700 ce qui veut dire que si l'image prise après le premier contrôle ( premier pipe |), constituée de 70 % lelargeur et 70 % de la hauteur est différente de l'image de référence ( avec la tolérance indiquée plus
bas), on stoppe le programme RobotSaisie, par contre pour le deuxième contrôle l'image comparée
est celle située entre le coin haut à gauche ( pixel : x=12,y=13) et le coin bas à droite ( pixelx=1000, y=700), avec la même règle d'arrêt en cas de divergence trop grande ( voir paramètretolérance plus bas).
• Un paramètre tolerance en pour-mille permettant de définir la tolérance d'écart de deux
images comparées pixel par pixel.
# Fichier de description des touches de controle a appliquer entre chaquecolonne#identifiee dans le fichier des données#la variable nbCol indique le nombre de colonne de chaque ligne du fichier dedonnées nbCol=#les lignes suivantes indiques les actions et controles a effectuer :#avant la premiere colonne colDeb<Action1>,<Pause_en_ms>,<Action2>,<pause_en_ms> ....#pour assurer la transition de la colonne n à la colonne n+1# apres la derniere colonne colFin => on met la les actions pour serepositionner# a la premiere colonne de la ligne suivante.#la syntaxe des actions correspond aux clés décrites dans le fichier destouches claviers soit clavier_FR.properties.#
#Temps d attente en milli secondes entre chaque touche
autoDelay=20
#freqLog definit la frequence des traces de log par rapport aux lignescontenues dans lengthfichier .csv.# A utiliser en cas de gros fichier .csv a integrer.
freqLog=1
#Nombre de colonne dans le fichier .csvnbCol=13
# profondeur = Pour-mille de pixels differents pour que deux images soientconsiderees comme differentestolerance=2
#Introduction d un checkpoint a l aide d image d ecran#sous la forme suivante chkpt_<cols>=<Action>_<Surface_Analyse>
#<cols> est de la forme chkpt_Deb pour comparer avec une image d ecran avantdebut de la saisie# soit la forme chkpt_Fin pour comparer avec une image située aores la saisiede la derniere colonne#soit la forme chkpt_col5_6 pour comparer avec une image avant la siaie de lacolonne 6## la surface d analyse peut prendre deux formes extends %80_%90 signfie que lasurface est constituee de#80% en largeur et 90% en hauteur de la taille de l ecran centre au milieu de lecran# l autre forme est X32Y45_X1000Y600 signifie que l'analyse est faitedans lerectangle constitue# le pixel en haut et a gauche (32,45) et le pixel en bas et a droite(1000,600)#En regle generale un controle avant le debut est suffisant si on veille arevenir a ce debut en fin de saisie de la lignecolDeb=|NULL,300chkpt_Deb=%86_%80
col1_col2=TAB,100chkpt_col1_2=col2_col3=TAB,100chkpt_col2_3=col3_col4=TAB,100chkpt_col3_4=col4_col5=TAB,100chkpt_col4_5=col5_col6=TAB,100chkpt_col5_6=col6_col7=TAB,100chkpt_col6_7=....
Important:
Il faut positionner les checkpoints avec précaution, l'idéal est de le positionner ( au moins) auniveau de de la colonne de début et aussi juste après avoir enregistré dans l'application et en fin dela dernière colonne. Ceci permet d'assurer une bonne intégrité des données.
Gestion de la souris et de la moletteL'outil d'enregistrement pour Windows RobotCaptureW.bat ou l'outil Linux
RobotCaptureL.ksh ( intégrés au workbench) permettent d'enregistrer automatiquement le clic de
souris ( et faire la distinction ente un clic droit et un clic gauche). Pour des manipulations de lasouris plus complexe ( drag and Drop ...) , l'outil RobotCaptureW et RobotCaptureL ne permettentpas ce genre de manipulation et il faut paramétrer à la main les fichiers en utilisant les menus outilsdu workbench.
Ci dessous l'explication des différents contrôles souris que l'on peut utiliser à l'aide de doublet decontrôle qui peuvent être positionné dans les fichiers .cnx, .dcx et .properties.
Rappel : le modificateur M est un entier dont la correspondance est donné ci dessous :
#pas de modificateur => 0 #SHIFT => 1 #ALT_GRAPH => 10 ( A voir avec Windows => peut etre aussi ALT + CONTROL) #ALT+CONTROL => 2 #CONTROL => 3 #ALT => 4 Les contrôles souris sont donnés ci-dessous :
MOVX_Y pour positionner la souris aux coordonnées X,Y
PRED_M Presser bouton droit avec Modificateur M ( M=0, ou M=2 ou M=3 ou M=4)
PREG_M Presser bouton Gauche avec Modificateur M ( M=0, ou M=2 ou M=3 ou M=4)
PREM_M Presser bouton Milieu avec Modificateur M ( M=0, ou M=2 ou M=3 ou M=4)
RELD_M Relâcher bouton droit avec Modificateur M ( M=0, ou M=2 ou M=3 ou M=4)
RELG_M Relâcher bouton Gauche avec Modificateur M ( M=0, ou M=2 ou M=3 ou M=4)
RELM_M Relâcher bouton Milieu avec Modificateur M ( M=0, ou M=2 ou M=3 ou M=4)
CLKD_M (Click Droit avec Modificateur M équivalent à PRED_M + RELD_M) ( M=0, ou M=2
ou M=3 ou M=4)
CLKG_M (Click Gauche avec Modificateur M équivalent à PREG_M + RELG_M) ( M=0, ou
M=2 ou M=3 ou M=4)
CLKM_M (Click Milieu avec Modificateur M équivalent à PREM_M + RELM_M) ( M=0, ou
M=2 ou M=3 ou M=4)
WHE_nb ( nb crans de roulette de souris nb peut être <0 ou >=0 )
Pour le paramétrage des fichiers, voir les chapitres dédiés à l'outil d'enregistrement inclus dans leworkbench.
Exemple de paramétrage sur mon PC. Fichier essai1.propertiesPour mon cas le fichier essai1.properties paramétré est celui donné ci dessous :
#Fichier des touches de controle pour le scenario : essai1# Fichier de description des touches de controle a appliquer entre chaquecolonne#identifiee dans le fichier des données#la variable nbCol indique le nombre de colonne de chaque ligne du fichier dedonnées nbCol=#les lignes suivantes indiques les actions et controles a effectuer :#avant la premiere colonne colDeb<Action1>,<Pause_en_ms>,<Action2>,<pause_en_ms> ....#pour assurer la transition de la colonne n à la colonne n+1# apres la derniere colonne colFin => on met la les actions pour serepositionner# a la premiere colonne de la ligne suivante.#la syntaxe des actions correspond aux clés décrites dans le fichier destouches claviers soit clavier_FR.properties.
#Temps d attente em milli secondes entre chaque touche#tolerance => indique l erreur admissible en pour mille en comparant 2 imagespixel a pixel#freqLog => donne la frequence d ecriture dans les fichiers de logs tous les nlignes du fichier .csvautoDelay=50freqLog=1tolerance=2#nbCol => Nombre de colonne dans le fichier .csv#nbCol => Nombre de colonne dans le fichier .csvcolDeb=|NULL,300chkpt_Deb=%70_%70# Valeur du fichier csv saisie avant ce controle : aacol1_col2=TAB,300chkpt_col1_2=# Valeur du fichier csv saisie avant ce controle : aacol2_col3=TAB,300chkpt_col2_3=# Valeur du fichier csv saisie avant ce controle : aacol3_col4=TAB,300chkpt_col3_4=# Valeur du fichier csv saisie avant ce controle : aacol4_col5=TAB,300chkpt_col4_5=# Valeur du fichier csv saisie avant ce controle : aacol5_col6=TAB,300chkpt_col5_6=# Valeur du fichier csv saisie avant ce controle : aacol6_col7=TAB,300chkpt_col6_7=# Valeur du fichier csv saisie avant ce controle : aacol7_col8=TAB,300chkpt_col7_8=# Valeur du fichier csv saisie avant ce controle : aacol8_col9=TAB,300chkpt_col8_9=# Valeur du fichier csv saisie avant ce controle : aacol9_col10=TAB,300chkpt_col9_10=# Valeur du fichier csv saisie avant ce controle : aacol10_col11=TAB,300chkpt_col10_11=# Valeur du fichier csv saisie avant ce controle : aacol11_col12=TAB,300chkpt_col11_12=# Valeur du fichier csv saisie avant ce controle : aacol12_col13=TAB,500chkpt_col12_13=# Valeur du fichier csv saisie avant ce controle : aacolFin=MOV584_553,300,CLKG_0,1481,|MOV541_615,300,CLKG_0,2700,MOV78_367,300,CLKG_0,1075,|NULL,300chkpt_Fin=%70_%70,%70_%70nbCol=13
Paramétrage fichier essai1.cnxVoir aussi les chapitres suivants sur les outils d'enregistrements des scénarios.
Pour ce qui concerne le fichier de connexion, pour notre exemple simple, le fichier est donné ci-
dessous :
#Fichier de connexion pour le scenario : essai1# Fichier de connexion a l'application a saisir#Fichier au format Java Properties# Parametres necessaires pour lancer l'application a travers la methodeRuntime.getRuntime().exec(...)# la commande doit inclure le chemin complet de l'executable ; les parametressont# sépares par des points-virgules et constitueront le tableau de String# l'ensemble Commande+parametres permettra de lancer l'application# selon la syntaxe Runtime.getRuntime().exec(String commande, String[]parametres)commande=c:\\Program Files\\Internet Explorer\\iexplore.exeparametres=file:\\\\c:\\Documents and Settings\\Jean-Louis\\MesDocuments\\home\\jlp\\netbeans\\RobotSaisieV44\\essai1.html# delai0 permet d'attendre que l'ecran de demarrage de l'application soiteffectivement affiche# delai0 permet d'attendre que l'ecran de demarrage de l'application soiteffectivement affichedelai0=3234#Saisie successives et controles clavier associés pour arriver a l ecraninitial de saisie# nbCouples indique le nombre doublet (textei controlei) necessaire pourafficher# le premier ecran de saisie. Les textei ou controlei peuvent être vides ou nepas exister pour l un d entre eux# Dans controlei on peut mettre une liste de controle sous la forme#<CONTROLE>,<TEMPS_PAUSE_EN_MS>,<CONTROLE>,<TEMPS_PAUSE_EN_MS>....texte1=controle1=MOV61_372,300,CLKG_0,9154nbCouples=1
Dans notre cas, la connexion est simple sans authentification ni mot de passe. Si tel est le cas, lemécanisme du couplage textei / controlei permet de réaliser cette connexion login/password. Leparamètre nbCouples indique le nombre de couplets textei/controlei. Les textei peuvent être vides.
Noter pour les chemins des commandes et des répertoires dans Windows, il ne faut pas oublier
d'échapper le caractère anti-slash \ par un anti-slah ; voir les paramètres commande et parametres.
Noter la commande c:\\Program Files\\Internet Explorer\\iexplore.exe file:\\\\c:\\Documents and
Settings\\Jean-Louis\\Mes Documents\\home\\jlp\\netbeans\\RobotSaisieV44\\essai1.html
Pour Windows, lors de l'enregistrement par RobotCaptureW les double anti-slash sontautomatiquement générés, on n'a pas à les doubler dans les paramètres de la ligne de commande dufichier RobotCaptureW.bat. Et pas ce genre de problème sous Linux !
Paramétrage fichier essai1.dcxPour ce qui concerne le fichier de déconnexion, pour notre exemple simple, le fichier est donné ci-dessous :
Fichier de deconnexion du scenario : essai1
# Fichier de Deconnexion a l'application a saisir#Fichier au format Java Properties# ddelai permet d'attendre ce temps en miliseconde avant l arret complet.## nbCouples indique le nombre doublet (textei controlei) necessaire pourquitter l'application#les saisies textei peuvent être vides, il peut manquer un des deux champs(textei ou controlei)# la premiere lettre d indique la deconnexion# une liste de controle sous la forme#<CONTROLE>,<TEMPS_PAUSE_EN_MS>,<CONTROLE>,<TEMPS_PAUSE_EN_MS>....ddelai=1075dtexte1=dcontrole1=ALT_F4,2000dnbCouples=1
Dans notre cas, la déconnexion est simple.. Le paramètre nbCouples indique le nombre de coupletstextei/controlei. Les textei peuvent être vides.
L' arborescence de ce scénarioL'arborescence des fichiers est imposé dans cette version 45x de RobotSaisie comme indiqué ci-dessous pour Windows ( On adaptera en conséquence pour Linux) :
• %workspace%\<scenario>\<scenario>.properties
• %workspace%\<scenario>\<scenario>.csv
• %workspace%\<scenario>\<scenario>.cnx
• %workspace%\<scenario>\<scenario>.dcx
• %workspace%\<scenario>\log\
• %workspace%\<scenario>\imgcheck\
• %workspace%\<scenario>\imgerr\
Les fichiers .cnx .dcx .properties .csv sont à positionner sous l'arborescence : %workspace%\<scenario>\ où scénario désigne le nom du scénario Voir ci-dessous exemple avec scénario essai. %workspace%\<scenario>\imgcheck\ ce répertoire contient les images checkpoint de référence, qui sont constituées au premier passagedans le checkpoint si elles n'existent pas déjà. %workspace%\<scenario>\imgcheck\ ce répertoire contient les images lors de la détection d'erreur. Le nom du fichier comporte la date de
la constitution du fichier.
%workspace%\<scenario>\log\ contient les logs constitués lors e l'exécution du scénario. Le nom
du fichier comporte la date de début de lancement du scénario, la structure d'une ligne de ce fichierest kla suivante
[<date_et_heure_de_traitement_de_la_ligne_fichier.csv]>;<Numero-de_ligne>;<OK_ou_KO>;<si_KO_fichier_image_erreur_si_OK_rien> ;
Exemple d'arborescence pour essai:
workspace = D :\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\essai
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\essai.properties
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\essai.cnx
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\essai.dcx
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\essai.csv
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\imgcheck\essai1chkpk_Deb_0_idx
_0_model.img
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\imgerr\essaichkpt_Deb....img
D:\home\jlp\netbeans\Developpement\RobotSaisieV4\essai\log\essai_2002_12_20_13_54_45.lo
g
Les images ( fichiers png dans notre cas de configuration) sont affichables à l'aide de InternetExplorer.
Si on veut réaliser un test, avant d'utiliser l'outil d'enregistrement il faudra créer l'arborescencecorrecte sous %workspace% et faire les copier coller pour servir les 4 fichiers .csv, .properties .cnxet .dcx.
Lancement de l'application et de RobotSaisie V453
Pour cela, par rapport à notre exemple, il faut que :
– qu'il existe un fichier de connexion ( essai1.cnx) et un fichier de déconnexion (essai1.dcx)
– un fichier de gestion de la boucle essai.properties
– un fichier de données au format csv essai.csv.
Le lancement à partir du workbench se fait ( après avoir lance RobotWindowW.bat ou
RobotWindowL.ksh) par l'enchaînement d'écrans suivants :
Choisir le scénario essai, cliquer sur Lancer, noter au passage le caractère d'interruption du scénarioen cours ( F9 par défaut paramétrable), cliquer sur OK et laisser faire.
Pour utiliser le mode frappe caractère par caractère, il faut positionner la variable copyAndPaste à
false dans le fichier de propriétés RobotSaisieV4.properties:
copyAndPaste=false
Cette modification est réalisable à partir des écrans de configuration vus plus haut.
GENERALISATION
Les étapes clés pour simuler la saisie dans une applicationCi dessous sont rappelées les étapes clés :
1)Faire une saisie modèle à l'aide des menus Enregistrer Scénario du workbench ( prendre de
préférence Enregistreme »nt par la souris)
2)Sauvegarder le fichier .csv contenant une ligne en .csv.modele
3) Préparer un fichier monAppli.csv contenant les données des champs à servir dans un fichier excelque l'on sauvegardera en mode cvs avec un séparateur au format du modèle récupéré en 2); . Ondevra avoir une ligne excel par cycle.
4) Vérifier dans les fichiers .cnx , .properties et .dcx que les temporisations sont correctes ( On peutperdre du temps lors de l'enregistrement, on doit vérifier aussi que les tempos longues nécessairessont bien positionnées).
5) Lancer le scénario à l'aide des menus Exécuter Scénario du workbench
Voir les chapitres suivants pour l'utilisation de ces outils d'enregistrements
MANUEL UTILISATEUR
Enregistrer des scénarios
But de l'outilL'outil permet de saisir directement dans l'application et enregistre en direct les saisie et lescontrôles effectués.
Cet outil ne fonctionne qu'avec Windows NT4, W2K et Win XP et Linux, il n'a pas été testé avecWIN 9x ou ME..
Cet outil est équipé d'un keylogger qui enregistre toutes les touches claviers mêmes celles nondestinées à l'application. Quand on enregistre un scénario, il faut donc mener l'enregistrement à sonterme et ne pas laisser l'outil fonctionner l'outil après que le scénario ait été enregistré.
L'auteur ne répond pas des utilisations frauduleuses qui pourraient être faites avec cet outil.L'utilisateur étant prévenu, c'est le seul responsable de la bonne utilisation de cet outil.
Cet outil permet d'enregistrer des clics de souris gauche et droit et on doit couvrir les besoins de laquasi totalité des IHM d'application. Pour les besoins plus avancés ( Drag and Drop), il faudraprogrammer les contrôles à la main ou en s'aidant des outils du menu Outils du workbench.
L'outil ne gère pas les mouvements de souris en continue, mais seulement les clics. Il déplace la
souris de «clic en clic» => en tenir compte lors des déplacements dans des menus avec sous menus (
ne pas oublier de cliquer dans l'item du menu avant de se déplacer dans les sous-menus)..
Résultats fournis par l'outil
A la fin de l'enregistrement, nous disposons donc des quatre fichiers nécessaires au fonctionnement
de RobotSaisie à savoir :
- .cnx contenant les données et les contrôles de la phase de connexion
- .properties contenant les contrôles de la phase de saisie répétitives
- .csv contenant une ligne donnant le modèle des données répétitives à rentrer
- .dcx contenant les données et les contrôles de la phase de déconnexion.
A noter aussi que pendant la phase d'enregistrement de la boucle ( fichier .properties), on peut poseren inter-actif les check-points de vérification.
Exemple d'utilisationPour décrire l'utilisation de l'outil nous nous appuierons sur l'exemple essai déjà utilisé dans cedocument.
Fichier de paramétrage de l'outil pour les captures
L'outil possède un fichier de paramètres qui décrit les codes des touches ainsi que les contrôlesutilisés pendant l'enregistrement. Ces fichiers de paramétrages sont accessibles à travers le menuconfiguration vu plus haut.
Le fichier pour Windows s'appelle RoborCaptureW.properties et est situé sous %base%.
Il faut veiller, lorsque on ajoute un contrôle dans le fichier clavier_FR.properties de bien
l'identifier comme contrôle dans le fichier RobotCaptureW.properties /
RobotCaptureL.properties dans une des variables CTRLi. Pour ce qui concerne les variables
CTRLi, il faut ouvrir les fichiers RobotCaptureW.properties / RobotCaptureL.properties dans
un éditeur de texte.
Un exemple de fichier clavier_FR.properties est donné en annexe 1 et un exemple de fichier
RobotCaptureW.properties est donné en annexe 2.
Pré-requis au lancement de l'outil
Afin de permettre la gestion du curseur et du sablier lors des attentes de saisie dans l'outil, il fautdéterminer le handle ( identifiant) des différents curseurs utilisés par l'application.
N'est vrai que pour Windows ; pour cela nous disposons de deux méthodes :
• automatique : au lancement de RobotSaisie.bat , un script détermine automatique les handlesdes curseurs systèmes
• manuel : par utilisation de l'utilitaire testCursor.exe . Et ceci uniquement pour Windows. Pas de gestion des curseurs sous Linux.
Les curseurs à déterminer sont : la flèche ( ARROW), le curseur Texte ( TEXTE), la flèche et lesablier ( ARROW_SABLIER), le sablier ( SABLIER), la main des liens URL ( HAND).
Nous conseillons la méthode automatique. Pour utiliser cette méthode automatique, il suffit de
placer la ligne suivante dans le fichier RobotSaisieV4.properties.:
Pour Windows :
FORCE_CURSOR=NO
Pour Linux on doit avoir FORCE_CURSOR à YES et mettre toute les valeurs à 0 pour les curseurscorrects et les autres à 11111111.
Mais si vous êtes masochiste, pour cela lancer d'abord l'application dans laquelle on va saisir.
Lancer dans une fenêtre de commande, sous l'arborescence %base% citée plus haut l'utilitaire
testCursor.exe.
Positionner la souris dans une zone qui n'est pas zone de texte et noter la valeur indiquée dans lafenêtre de commande par la variable : hCursor. Et essayer de voir en ayant sur le même écran, lafenêtre de commande et la fenêtre de l'application de déterminer les handles des différents curseurs.
Ces valeurs sont à positionner dans le fichier RobotSaisieV4.properties.
Nota : Pour NT4, le handle du curseur HAND est variable, en fonction des lancements de
l'application, il convient de mettre sa valeur à 0. RobotSaisie sait gérer ce cas.
Ces valeurs évoluent d'un OS Windows à l'autre et en fonction des icônes de pointeurs paramétréesdans l'OS.
Lancement de l'outilPour lancer l'outil, il suffit d'enchaîner les écrans suivants :
On n'étudiera que le sous-menu Contrôle Souris, le sous-menu contrôles clavier est laissé par
compatabilité avec versions antérieures. Dans la version Linux seul l'enregistrement avec contrôlesouris ( le plus ergonomique) est proposé.
Puis réaliser les opération suivantes :• Remplir le nom du scénario ( essai par exemple)• Remplir le chemin complet du programme à lancer ( s'il y a eu des enregistrements précédents la
combobox en dessous garde un historique qui permet éventuellement de choisir le programme àlancer)
• Remplir le champ des paramètres éventuels, séparés par des espaces si plusieurs paramètres ( demême la combobox en dessous garde un historique des paramètres déjà utilisés)
• Remplir le champ du nom de programme à tuer en cas d'échec de l'arrêt ( on peut déterminer ceprogramme à l'aide du gestionnaire de taches windows / onglet processus ou du classique ps souslinux).
Une fois servi, l'écran doit ressembler à cela :
Ce qui va lancer l'application de test livrée avec ce logiciel.
Fonctionnement avec contrôles Souris
Rappel des 3 phases de l'enregistrement et de l'exécution d'un scénario :– 1ière phase : phase de connexion ( qui peut être plus ou moins complexe)– 2ième phase : phase de boucle permettant de saisir 1 à n enregistrements dans une application– 3ième phase : phase de déconnexion à la fin des saisies.
Pour pouvoir utiliser correctement le scénario, et notamment pouvoir saisir des données ennombres, il faut bien veiller à :• à bien déterminer le point de fin de connexion dont l'écran coïncide avec le début de la première
boucle • à bien déterminer le point de boucle qui doit être le même que le point de début de boucle et
correspondre au point de début de déconnexion.Nous verrons aussi, comment implémenter des points de contrôles par des copies d'écrans ou deportions d'écrans.
Après avoir cliqué sur Lancer, nous voyons apparaître sur l'écran, le premier écran de l'application
A ce stade nous posons un point de contrôle pour vérifier l'affichage de l'écran :pour cela, nous positionnons la souris dans le coin haut et gauche et l'écran suivant apparaît:
Nous notons que nous sommes en phase de connexion. Nous cliquons sur le bouton Photo pourprendre un cliché de l'écran et apres avoir cliqué nous devons retrouver cette image :
Ce qui correspond à l'image de l'écran en mode de netteté moindre pour le distinguer del'application réelle. On peut dans cette image choisir une portion significative d'écran en définissantun rectangle par 2 clics gauche de la souris ( 1 clic en haut à gauche et un clic en bas à droite, onpeut corriger le rectangle)On peut avoir, après sélection ( facultative) du rectangle, l'image suivante :
En repositionnant la souris sur le coin haut gauche de l'écran on a l'écran suivant :
On clique sur le bouton Flash pour obtenir l'enregistrement de l'image choisie et on revient à l'écranapplicatif, pour poursuivre la saisie. ( Nota : ne pas tenir compte du nombre d'évenements, ilcorrespond ici aux différentes manoeuvres pour réaliser ce document)Nous simulons une connexion en rentrant deux champs dans les deux premiers textfields :
puis nous cliquons sur Submit pour obtenir l'écran suivant :
sur lequel on fait une photo comme indiqué juste au-dessus et on reclique sur submit pour revenit
à :On refait une photo, et on considère que la phase de connexion est terminée. On remet donc lasouris en haut à gauche de l'écran pour cliquer sur le bouton CnxToBcl
et on revient sur l'écran applicatif vide de l'application. Comme c'est un point caractéristique del'application on refait une photo de l'écran puis on saisit l'écran pour obtenir quelque chosesemblable à cela :
On clique sur Submit,
et on prend une photo
on reclique sur Submit et on reprend une photoLa réalisation de la boucle est alors terminée, on passe en phase de déconnexion: placer la souris enhaut et à gauche de l'écran
et cliquer sur le bouton BclToDcxon revient dans l'écran applicatif et on exécute les saisies nécessaires à l'arrêt de l'application ou duclient applicatif.
Important : pendant la phase de déconnexions on ne peut pas faire de photos d'écrans.
En fin de déconnexion : on se retrouve en positionnant la souris en haut et à gauche avec cet écran :
on clique sur DcxToFin et on repositionne la souris en haut à gauche de l'écran :
on clique sur Fini et puis on clique sur Fichier/Generer scénario
Et le scénario se génère. On peut ensuite visualiser les 4 fichiers ( .cnx, .csv, . Properties et .dcx encliquant sur Voir scénario )
Ces fichiers sont modifiables en ligne. On peut aussi les modifier ensuite depuis le menu Fichier /Voir Scénarios du Workbench.On clique sur Quit puis Fichier / Quit pour revenir à l'écran principal du workbench.
On peut lancer ensuite le scénario par l'enchaînement d'écrans décrits plus haut pour un scénariosimple.
Pour info : fonctionnement avec contrôles claviers ( sous
Windows seulement)Le premier écran ci-dessous vous donne 2 informations :
• d'une part le raccourci clavier qui va vous permettre de basculer de l'application à enregistrer àRobotCaptureW ( et vice-versat) ( ALT_F9 dans ce cas)
• D'autre part le raccourci clavier qui va vous permettre d'introduire des contrôles pendant laphase de boucle.
A noter que ces contrôles sont paramétrables dans le fichier RobotCaptureW.properties par leslignes ci-dessous ( voir Annexe 2) :
CAR_BASCULE=ALT_F9
CAR_CONTROLE=F9
Il faut aussi que ces raccourcis soient déclarés dans clavier_FR.properties et dans la liste des
contrôles CTRLi de RobotCaptureW.properties
L'écran ci-dessous est l'écran de lancement de l'application dans laquelle on veut enregistrer :
ECRAN 1
On se positionne avec la souris sur le premier champ produit et on clique gauche ( On a fini pour cetexemple simple la phase de connexion). On doit passer en suite en phase d'enregistrement des
boucles. Pour cela, on bascule dans RobotCaptureW par ALT_F9 et on a l'écran suivant. On
choisit dans la combo-box la phase boucle et on rebascule vers l'application par ALT_F9.
ECRAN 2
L'écran de RobotCaptureW est en haut et à droite de l'écran. Après avoir choisi boucle dans la
combo-box, et re-basculé par ALT_F9, on saisie les données et on fait une boucle complète pourrevenir en bout de boucle. On peut introduire par F9, des checkpoints pendant cette boucle sur desécrans ou portion d'écrans invariables ( début de boucle, écrans vierges de données utilisateurs quiserviront par la suite à RobotSaisie ).
ECRAN 3
on clique sur submit, on retrouve l'écran 2 ci dessous :
ECRAN 4
et en re-cliquant sur submit on revient à l'ECRAN 1 plus haut.On peut introduire un checkpoint parF9.( Voir paragraphe plus loin sur la nouveauté de la Version 4.5.1)
Ensuite on doit terminer par la phase de déconnexion. Donc taper ALT_F9, puis choisir dans la
combo-box la phase dcx, et revenir dans l'application pour saisir les touches de déconnexions sauf
la dernière ( qui devra être rajoutée manuellement au scénario. Voir plus bas)
Ensuite il faut passer à la génération du scénario. Avant donc, la dernière touche de déconnexion ( à
ne surtout pas saisir), taper ALT_F9, puis choisir dans la combo-box, la valeur Fini! et ensuite
choisir Fichier-> Generer Scenario
Le clic sur le menu «Generer Scenario» génère les scénarios et ensuite le menu «Voir Scenario» estaccessible et ouvre un écran avec 4 onglets, correspondant aux fichiers nécessaire au scénarioenregistré.
Les données sont modifiables directement dans ces écrans. Ou on peut le faire par la suite à traversun éditeur en mode texte pour adapter et mettre au point les scénarios ( optimisation destemporisations, rajout de contrôles ou de checkpoints, ....).
Nota important : les checkpoints ne sont positionnables que dans la phase de connexion et de
boucle et pas dans la phase de déconnexion.
Evolution de la saisie des checkpoints à partir de la version
4.5.3.
Quand on frappe la touche de saisie de checkpoint ( cas de l'enregistrement par contrôles claviers :F9) dans notre cas, le logiciel ouvre un écran avec l'image écran de l'application en cours de saisiepour automatiser la saisie des contrôles par l'image. L'image apparaît en mode floue, pour ladifférencier de l'application réelle.
On peut en cliquant 2 fois ( 1 point situé en haut à gauche et un point situé plus bas et plus à droite)définir un rectangle sur lequel portera la comparaison d'image par rapport à un modèle. On ferme
par F9 dès que le rectangle nous convient. On veillera à n'intégrer que des rectangles significatifs,ne se modifiant pas d'une boucle de données à l'autre, mais cependant discriminant d'un changementd'écran à l'autre ( Les titres des fenêtres, des panneaux ou des onglets sont de bons candidats decomparaisons d'images).
Si on frappe 2 fois F9 ( Ouverture) et F9 (Fermeture de l'image) sans cliquer 2 fois, la zone decomparaison d'image est la zone par défaut à savoir : 70%en hauteur et 70%en largeur d'écran,centré au milieu de l'écran.
On ne peut introduire qu'un seul rectangle dans un écran. On peut faire un contournement, enrajoutant un contrôle NULL et en faisant une comparaison d'image sur une partie complémentairede l'écran. Exemple d'écran avec choix d'un rectangle de comparaison :
Menu OUTIL / Position Clic Souris
But de cet outilL'utilisation de cet outil en mode standalone, permet de repérer sur l'écran les coordonnées X et Yen pixels, sur lesquelles doit porter un contrôle de la souris.
L'utilisation de cet outil peut être obligatoire pour l'intégration de saisie et contrôle contextuels dansle fichier de données .csv ou pour l'utilisation de contrôle souris plus complexe tels que les drag anddrop. Voir plus loin, le chapitre utilisation avancée de RobotSaisie.
Principe d'utilisation
Comme dit plus haut, cet outil d'appoint permet de rajouter des contrôles souris qui ne peuvent êtreenregistrés directement à l'aide de l'enregistrement automatique décrit dans le chapitre précédent.
Pour rajouter ces contrôles soit dans le fichier .properties ou soit dans le fichier .csv, il faut notersur une feuille papier les coordonnées sur lesquelles seront faites le contrôle souris.
Lancement
Depuis le workbench :
Pour revenir au workbench en fin d'utilisation de cet outil, faire un clic droit.
Mode Opératoire
ll faut suivre la démarche suivante :- ouvrir l'application sur l'écran ou on veut enregistrer le contrôle souris. - lancer l'outil SourisParam à l'aide du fichier SourisParam.bat - par la commande ALT+TAB revenir à l'écran de l'application à saisir. - positionner la souris à l'endroit de l'écran ou doit porter le contrôle souris - sans bouger la souris et par ALT+TAB revenir au tableau Blanc et cliquer la souris
- noter les coordonnées X,Y de la souris - compléter le fichier .properties ou .csv avec ce contrôle
Exemple de contrôle que l'on peut rajouter ainsi MOV328_542,300,CLKG_1,1000 Pour rajouter les contrôles suivant : bouger la souris au pixel X=328 et Y=542, attendre 300 ms etfaire un SHIFT CLICK GAUCHE de la souris et attendre 1000 ms.
Utilisations avancées de RobotSaisie
Cas particulier à couvrir des lignes de données à nombres de
colonnes variablesLe cas particulier à couvrir est le cas où les lignes à enregistrer peuvent avoir un nombre decolonnes qui peut varier d'une ligne à l'autre en fonction du contenu fonctionnel de la ligne.
Les solutions possibles
La solution la plus simple est d'écrire un scénario par type de ligne et d'éclater le fichier desdonnées à rentrer en autant de fichiers que de scénarios écrits.
Soit un scénario et un fichier de données comportant n colonnes, un scénario et un fichier dedonnées comportant n+1 colonnes et ainsi de suite en fonction de la variabilité du nombre decolonnes.
Une autre solution consiste, à utiliser les saisies et contrôles contextuels que l'on peut introduiredans le fichier .csv. Il faut ensuite modifier le fichier .csv pour intégrer ses saisies et contrôlescontextuels dans la bonne colonne. Cette solution permet d'avoir qu'un seul scénario et un seulfichier de de données .csv. On altère cependant un peu la lisibilité de ce fichier .csv en mélangeantles données et les contrôles.
La solution des données et contrôles contextuels
Il faut commencer par enregistrer le scénario qui aura le moins de colonnes dans le fichier .csv pouravoir une ligne initiale modèle.
Ensuite à l'aide du fichier des données de masses à saisir dans l'application, il faudra créer toutes leslignes à saisir dans l'application en y incluant les données et contrôles contextuels à saisir enfonction de la ligne. Pour fabriquer ce fichier, il faut d'une part que dans le fichier initial, il y ait uneinformation à partir de laquelle on puisse générer les données et contrôles contextuels et d'autredisposer d'un outil automatique de génération de ces lignes correctement remplies.
Pour ce qui concerne l'outil, il y en a un qui correspond bien à ce besoin c'est awk. Mais vous medirez awk c'est unix !! A cela je vous réponds : pas seulement. Pour le portage des outils unix souswindows, voir le paquetage Cygwin. Pour l'installer voir sur le site de Redhat .
Le but ici n'est pas d'expliquer awk, voir sur le net la documentation existante sur awk.
Syntaxe des données et contrôles contextuels dans le fichier .
csv
La syntaxe d'une colonne du fichier .csv comportant des données contextuelle est la suivante :
...;donnee1[{Controle1,tempo1,Controle2,tempo2...}]donnee2[{Controle3,tempo3...}];... les caractères "[{" et "}]" indiquent respectivement le début et la fin des contrôles contextuels. On peut rentrer plusieurs données ( donnee1, donnee2...) entre 2 point-virgule en fonction de laligne. Les données contextuelles peuvent être vides. Les contrôles sont les mêmes que ceux utilisés dansle fichier .properties.
Important : il faut que les derniers caractères constituant une colonne de données et contrôles
contextuels soient "}]". Exemple: ...;...;abcd[{TAB,300,TAB,500}]efg[{MOV353_456,300,CLKG_0,5000}];...; qui permet dans une colonne «physique» ( séparée par des;) de saisir deux colonnes « logiques »données+contrôles. On peut faire varier d'une ligne à l'autre le nombre et le contenue de ces colonnes «logiques».
ASTUCES
Contrôles NULLA partir de la version 4 de RobotSaisie, on peut rentrer directement des délais d'attente > 60000 mssans décomposer.
On rentre la valeur en ms exemple TAB,60000000 pour 60 000 s
Le contrôle NULL est conservé pour compatibilité et autres utilisations avancées.
Un contrôle NULL permet de créer une action nulle et de générer une attente.
On aura alors des lignes de contrôle du type :
controle12=...,NULL,60000,NULL,60000,NULL,30000,...
pour une attente de 2mn et 30s dans un fichier .cnx. On peut faire de même pour les contrôles desfichiers .dcx et .properties.
Rajout d'un contrôle
Tous les contrôles doivent être décrits dans le fichier clavier_FR.properties.
Si un contrôle n'est pas décrit, il faut l'insérer dans le fichier clavier_FR.properties avec le code
approprié. Imaginons que nous ayons besoin du contrôle ALT_Y ( appuie simultané sur la touche ALT et sur
la touche Y). Ce contrôle n'est pas décrit dans le fichier clavier_FR.properties.
Pour cela on dispose de l'outil KeyEventDemo . Se positionner sous l'arborescence des binaires de l'outil, si on a respecté les répertoires décrits dansce document :
cd c:\util\RobotSaisieV453
.\lanceKeyW.bat ( resp lanceKeyL.ksh )
ou utilser le menu Outil / Codes Touches Clavier du Workbench.taper y dans le champ de saisie supérieur et noter le code correspondant à KeyPressed ouKeyReleased. Soit 89.
pour le modificateur ALT, l'en-tête du fichier clavier_FR.properties donne 4.
Il faut donc rajouter dans le fichier clavier_FR.properties, la ligne suivante :
ALT_Y=89_4
Important:
Pour l'utilisation de RobotCaptureW / RobotCaptureL, il faut aussi ajouter ce contrôle dans la
liste des contrôles CTRLi. Une des variables : CTRLi du fichier RobotCaptureW.properties /
RobotCaptureW.properties.
Attention :
L'ajout d'un contrôle dans le fichier clavier_FR.properties à l'aide du workbench ne met pas
à jour les proprités CTRLi des fichiers RobotCaptureW.properties /
RobotCaptureW.properties ; s'il s'agit bien d'un contrôle ( opposé à acractère saisissable) il
faudra compléter ces fichiers à la main.
Utilisations Diverses de RobotSaisie
Présentation
Le workbench permet le lancement de scénario ssimples comme indiqué jusqu'ici, et de plus ilpermet de lancer plusieurs scénarios enchainés, un scénario exécutant un nombre défini de la mêmeboucle ou de schéduler des lancements à travers un mécanisme de schéduleur. Les differents typesde lancements se font à partir des sous-menus du menu executer un scénario et des paramètres àpositionner. On trouvera dans le tableau ci-dessous les possibilités de paramétrage de ces variables.
Les paramètres importants sont -DTimer, -DtraceXML -DboucleInfini.
Nota : il existe un paramètre de lancement en mode debug que l'on peut positionner :
-DDEBUG="true" . Les traces dans la console sont plus verbeuses et indiquent les chaînes de
caractères et les contrôles saisies.
Tableau des valeurs possibles et comportement de RobotSaisie
Parametre Timer traceXML boucleInfini Commentaires
Plage de
valeurs
false /
true
false / true false / n
n=nombre
de boucles
CAS 1 false false false Cas simple d'usage de RobotSaisie, sans trace XML
CAS 2 false false <n> Cas d'usage sans trace XML de test en boucle ( sans réel intérêt )
CAS 3 false true false Cas nominal d'usage de RobotSaisie, sans trace XML
CAS 4 false true <n> Cas d'usage nominal avec trace XML de test en boucle
CAS 5 true false false Lancement programmé de scénario sans trace XML ( Sans intérêt)
CAS 6 true false <n> Lancement programmé de scénario dans trace XML avec un certain
nombre de boucle ( Sans intérêt)
CAS 7 true true false Lancement programmé de scénario avec trace XML cas nominal
Parametre Timer traceXML boucleInfini Commentaires
CAS 8 true true <n> Lancement programmé de scénario avec trace XML et boucle infini
cas nominal
Nota : les cas les plus utilisés sont en fond bleu dans le tableau ci-dessus : CAS 3 : => correspond au lanceur classiqueCAS 4 : => Correspond au lanceur avec test en boucle , pour tester la robustesse d'un client ( fuiteMémoires, comportement en itération nombreuses sur les mêmes données) CAS 7 et 8 => Correspond aux lancements schédulés de plusieurs scénarios , on peut scheduler etmesurer des temps d'exécutions de scénarios.
Le CAS 7 permet de gérer le déroulement de plusieurs scénarios qui vont saisir toutes leslignes valides du fichier .csv.Le CAS 8 permet de gérer le déroulement de plusieurs scénarios qui vont saisir en bouclela première ligne valide du fichier .csvOn ne peut panacher les 2 paramétrages car le paramêtre est passé au lancement de la JVM.Mais on peut contourner le problème si le parametre boucle infini est à false, en écrivant nfois la même ligne dans le fichier .csv.
On peut ensuite adapter toute combinaison à des fichiers de lancement différents.Dans les cas : CAS 1 à CAS 4, si on ne met pas de paramètre de scénario au lanceur, il va chercher
sous le répertoire pointé par la variable d'environnement %workspace%, le fichier listeScenario.txt
dont un exemple est donné ci-dessous : # Fichier listeScenario.txt # # RobotSaisieV453. Auteur JL PASTUREL # Ce fichier contient la liste des scenario a lancer # # # la ligne type est donne par l 'exemple ci-dessous # Les scenario sont separes par des points virgule #listeScenario=scenario1,scenario2;scenaio3;... ##enchainementScenario a true (resp false) force ( resp empeche) l'excecution du scenario suivanten#cas d echec du scenarion en coursenchainementScenario=truelisteScenario=essai1;essai2
Noter le paramètre enchainementScenario qui permet de décider d'arrêter ou de continuer en cas
d'échec d un scénario.Ce fichier est accessible et modifiable depuis le workbench ( menu Executer scénario / ScénariosEnchaines)
Le fichier timerScénario.properties
Ce fichier doit être situé sous l'arborescence pointé par la variable d'environnement workspace.
La syntaxe du fichier est similaire au fichier crontab UNIX. Vous trouverez ci-dessous un exemplede ce fichier.
A noter la limitation qui interdit de choisir en même temps un jour de semaine et un jour du mois.C'est à dire que l'on ne sait pas programmer des scénarios qui devraient s'exécuter tous les vendredi13. On sait programmer des scénarios qui s'exécutent tous les 13 du mois, ou (ou exclusif ) tous lesvendredi. Ce fichier est accessible et modifiable depuis le workbench ( menu Executer scénario / ScénariosSchédulés). On peut aussi, si on a servi une durée estimée de chaque scénario, procéder à unesimulation des n prochains lancements ( n paramétrable).
Lire attentivement les commentaires du fichier.
# les regles de remplissage pour les timer sont similaires aux regles utiliséespour le crontab Unix# Le separateur de champ est le ;# le separateur d'occurence dans un champ est la virgule ,# On pourra utiliser aussi le signe - dans un champ pour définir un intervallede valeurs ( 0-5 par exemple). le pas est de 1# On ne pourra pas panacher les , et le -# pour Heures : * veut dire toutes les heures identique à 0-23 ; 0,6,7 listeles heures de lancements; 0-5 toutes les heures de 0h à 5h# Pour Minutes : idem mais plage 0-59# Pour Secondes : ident mais plage 0-59# Pour Jour semaine : idem mais plage 1-7 ( 1=Dimanche)# Pour jour du mois : idem mais plage variable de 1-28, 1-29, 1-30, 1-31 enfonction du mois et de l'année# Noter : Il y a exclusion entre le jour de la semaine et le jour du mois => undes deux doit être avec une *# Si on veut gerer une exception ne rentrant pas dans ce parametage, on creeraune copie du scenario sous un autre nom et on# introduira une ligne supplementaire dans ce fichier.# Pour Mois : idem mais plage 1-12 ( 1=Janvier)# Pour Année : idem à Partir de 2004# Exemple#Nom du ; H ; Mn ; S ; J_S ; J_M ; M ;A;Durée en secobe# Scenario#gantt2 =9,10,14,23;0,10,20,30;0;1,2,3,4,5;*;*;2004
gantt2 =9,10,14,23;0,10,20,30,40,50;0;1,2,3,4,5;*;*;2004;120gantt1 =11,12,13;0,10,20,30;0;1,2,3,4,5;*;*;2004;50#gantt3 =11,12,13,22;15;0;7;*;*;2004;120#gantt4 =*;30;0;*;*;1;2004;120#essai1=*;0,5,10,15,20,25,30,35,40,45,50,55;0;*;*;*;2004;120#essai1=*;0,5,10,12,15,17,20,25,28,30,32,35,37,40,42,45,48,50,52,55,57;0;*;*;*;2004;120essai1=16;21;0;*;24;1;*;50#essai1=*;0,10,20,30,40,50;0;*;*;*;2004;60#essai2=*;5,15,25,35,45,55;0;*;*;*;2004;60
Arrêt forcé du scenario.Les scénarios proposent pour la déconnexion un ensemble de contrôle décrits dans le fichier<scenario>.dcx. Or ceci n'est valide que si le scénario se déroule correctement. En cas de problèmedans un scénario, identifié par la comparaison de deux écrans, il peut y avoir un grand nombre decas de déconnexions possibles.
L'outil prévoit dans ce cas de tuer violemment les processus windows.
Pour trouver les noms des processus applicatifs, il y a sous l'arborescence %base%, un utilitaire
appelé listPs. Pour avoir tous les processus qui sont lancés faire listPs -l . On peut avoir les
processus liés à l'application par différence: en lançant listPs -l avant lancement de l'application etaprès l'avoir lancée.
La liste des processus que l'on doit tuer en cas de problème et à placer dans le fichier : killer.txt
Ci-dessous un exemple de fichier killer.txt
# Fichier killer.txt # # RobotSaisieV453. Auteur JL PASTUREL # Ce fichier contient la liste des processus a tuer en fin deconnexion # Si la deconnexion est normale. On n'a pas de processus à tuer # Il est utile de tuer ces procesus en cas d'erreur dans l'execution du script # la ligne type est donne par l 'exemple ci-dessous # Les processus sont separes par des points virgule #listeProcessus=processus1;processus2;... # # Pour trouver le nom des processus , utiliser l'utilitaire listPs.exe, sous l'arborescence des # binaires de RobotSaisieV45 lancer : .\listPs.exe -l # # listeProcessus=IEXPLORE.EXE
Ce fichier est rempli lors la création du scénario lors du remplissage du champ : « Programme à tueren fin de scénario »
La génération des traces XMLApres avoir exécuté un scénario, avec la variable d'environnement traceXML à true ( CAS :3,4,7,8), le workbench crée automatiquement les traces HTML. Ce programme va scruter tous les
scénarios sous %workspace% , et s'il trouve des fichiers dont le nom est de la forme
<scenario>Agreg.xml, il applique la tranformation XSLT, pour créer sous l'arborescence du
scénario le fichier html dont le nom est du type : <scenario>Agreg.html .
Sous le répertoire %workspace% , générerHTML crée un fichier d'index HTML : indexPerf.html
qui va pointer vers toutes les traces des scénarios exécutés.
Les traces HTML et les logs d'executions de chaque scénario sont accessibles depuis le workbench :
Ci-dessous un extrait de ces deux types de fichier.
indexPerf.html :
LISTE DES PERFORMANCES
DISPONIBLESCi-dessous la liste des performances disponibles.
Cliquer sur le lien URL pour afficher les resultats
Scenario URL
essai1 Performance scenario : essai1
essai3 Performance scenario : essai3
essai3Agreg.html :
PERFORMANCE DU SCENARIO : essai3Nota : Toutes les mesures sont en secondes. Les cellules rouges indiquent une erreur lors de
l'execution du scenario. L'hyperlien du nom du scenario donne l'image en erreur, l'hyperlien
de la date donne l'image attendue.
Scenario Date Temps de
Connexion
Boucle Temps de
deconnexion
Total
essai3 2004/01/2515:52:20
16 16 1 33
Scenario Date Temps de
Connexion
Boucle Temps de
deconnexion
Total
essai3 2004/01/25
15:55:18
16 50 1 67
essai3 2004/01/25
16:15:11
16 89 1 106
essai3 2004/01/25
16:21:57
94 -5 1 90
essai3 2004/01/25
16:38:56
16 38 1 55
essai3 2004/01/2516:45:51
16 16 1 33
essai3 2004/01/25
16:52:20
16 85 1 102
essai3 2004/01/25
16:55:30
16 38 1 55
essai3 2004/01/25
16:59:47
16 19 1 36
essai3 2004/01/25
17:07:17
16 18 1 35
essai3 2004/01/25
17:14:18
16 19 1 36
essai3 2004/01/2517:31:44
16 16 1 33
essai3 2004/01/2518:19:12
16 16 1 33
essai3 2004/01/25
18:23:00
16 18 1 35
essai3 2004/01/2518:26:11
16 15 1 32
Les cellules rouges indiquent des échecs. Les cellules rouges indiquent une erreur lors de
l'exécution du scénario. L'hyperlien du nom du scénario donne l'image en erreur, l'hyperlien de ladate donne l'image attendue.
ANNEXE 1 : clavier_FR.properties ( Exemple)# Application RobotSaisie. Fichier de parametrage du clavier# Ce fichier de properties decrit les keycodes des touche claviers# en dehors des touches correspondant a la codification ASCII# les touches qui correspondent a la numerotation ascii sont :# [A-Z] , [0-9], [a-z]## Pour parametrer le clavier : utiliser le programe KeyEventDemo issu de SUNmodifie# en application : java KeyEventDemo.#Chaque ligne a la structure ci-dessous#<NOM_TOUCHE>="<KEYCODE>_<MODIFICATEUR>"#Les modificateurs sont#pas de modificateur => 0#SHIFT => 1#ALT_GRAPH => 10 ( A voir avec Windows => peut etre aussi ALT + CONTROL)#ALT+CONTROL => 2 ( A voir avec Windows => peut etre aussi ALT_GRAPH)#CONTROL => 3#ALT => 4#ALT_E=69_4ALT_V=86_4COPY_PASTE=86_3ALT=18_0SHIFT=16_0CONTROL=17_0ESPACE=32_0AMPERSAND=49_0E_AIGU=50_0DOUBLE_QUOTE=51_0SIMPLE_QUOTE=52_0PARENTHESE_GAUCHE=53_0MOINS=54_0E_GRAVE=55_0UNDERSCORE=56_0C_CEDILLE=57_0A_ACCENT=48_0PARENTHESE_DROITE=522_0EGALE=61_0BACKSPACE=8_0DOLLAR=515_0RETURN=10_0TAB=9_0SHIFT_TAB=9_1STAR=151_0SHIFT=16_0INFERIEUR=153_0VIRGULE=44_0POINT_VIRGULE=59_0DEUX_POINTS=513_0POINT_EXCLAMATION=517_0FLECHE_GAUCHE=37_0FLECHE_HAUTE=38_0
SHIFT_FLECHE_HAUTE=38_1SHIFT_FLECHE_DROITE=39_1SHIFT_FLECHE_BAS=40_1SHIFT_FLECHE_GAUCHE=37_1PAGE_UP=33_0PAGE_DOWN=34_0SHIFT_PAGE_UP=33_1SHIFT_PAGE_DOWN=34_1FLECHE_BAS=40_0FLECHE_DROITE=39_0ENTER=10_0LF=13_0SUPPR=127_0INSERT=155_0FIN=35_0ESCAPE=27_0F1=112_0F2=113_0F3=114_0F4=115_0F5=116_0F6=117_0F7=118_0F8=119_0F9=120_0F10=121_0F11=122_0F12=123_0CONTROL_F1=112_3CONTROL_F2=113_3CONTROL_F3=114_3CONTROL_F4=115_3CONTROL_F5=116_3CONTROL_F6=117_3CONTROL_F7=118_3CONTROL_F8=119_3CONTROL_F9=120_3CONTROL_F10=121_3CONTROL_F11=122_3CONTROL_F12=123_3ALT_F1=112_4ALT_F2=113_4ALT_F3=114_4ALT_F4=115_4ALT_F5=116_4ALT_F6=117_4ALT_F7=118_4ALT_F8=119_4ALT_F9=120_4ALT_F10=121_4ALT_F11=122_4ALT_F12=123_4NUMERO=522_1PLUS=61_1LIVRE=515_1#SOLEILSOLEIL=515_2#POURCENT="a determiner"MU=151_1SUPERIEUR=153_1POINT_INTERROGATION=44_1POINT=59_1SLASH=513_1
PARAGRAPHE=517_1# Pour la suite a analyser en fonction du parametrage clavier# A voir avec Windows si ALT_GRAPH (10) est connu# sinon passer par ALT+CONTROL (2)TILDE=50_2DIESE=51_2ACCOLADE_GAUCHE=52_2CROCHET_GAUCHE=53_2PIPE=54_2ANTI_QUOTE=55_2ANTI_SLASH=56_2ACCENT_CIRCONFLEXE=57_2AT=48_2CROCHET_DROIT=522_2ACCOLADE_DROITE=61_2NULL=9999_9999null=9999_9999#Click gauche sourisCLCKG=1_0#Click Doit SourisCLCKD=2_0
ANNEXE 2 : RobotCaptureW.properties
(Exemple)attenteLancement=10#description des touche clavier francaisclavier=clavier_FR.properties#timeout du Robot apres une saisieautoDelay=20bascule=ALT_TAB,1000# Caratere de bascule 2=clic droit souris. Permet de naviguer entre la fenetrede RobotCaptureW# et la fenetre de l'application sans que ce caractere soit saisie.# on peut saisir choisir un autre caractere de bascule type touche fonctionCAR_BASCULE=ALT_F9CAR_CONTROLE=F9#Time out apres chaque controletimeOutControle=2000# Liste des ControlesCRTL=;TAB;F1;F2;F3;F4;F5;F6;F7;F8;F9;F10;F11;F12;LF;ENTER;FIN;INSERT;PAGE_UP;PAGE_BAS;FLECHE_GAUCHE;FLECHE_DROITE;FLECHE_HAUTE;FLECHE_BAS;CONTROL_S;CONTROL_V;ALT_A;ALT_R;ALT_V;ALT_TAB;CTRL1=;TAB;F1;F2;F3;F4;F5;F6;F7;F8;F9;F10;F11;F12;LF;ENTER;FIN;INSERT;PAGE_UP;PAGE_BAS;CTRL2=;FLECHE_HAUTE;FLECHE_DROITE;FLECHE_BAS;ALT_A;ALT_R;CONTROL_V;CONTROL_C;CONTROL_S;ALT_V;CTRL3=;SHIFT_PAGE_BAS;SHIFT_PAGE_HAUT;SHIFT_TAB;CTRL4=;ALT_F1;ALT_F2;ALT_F3;ALT_F4;ALT_F5;ALT_F6;ALT_F7;ALT_F8;ALT_F9;ALT_F10;ALT_F12;CTRL5=;FLECHE_GAUCHE;FLECHE_DROITE;PAGE_HAUT;PAGE_BAS;CTRL6=;ESCAPE;CTRL7=;CLCKG;CLCKD;CTRL8=;CTRL9=;MODIF=;SHIFT;ALT;CONTROL;ALT_GR32_0=32_1=32_2=49_0=&49_1=150_0=é50_1=250_2=~51_0="51_1=351_2=#52_0='52_1=452_2={53_0=(53_1=553_2=[54_0=-54_1=654_2=|55_0=è55_1=755_2=`
56_0=_56_1=8# Doubler l antislash56_2=\\57_0=ç57_1=957_2=^48_0=à48_1=048_2=@219_0=)219_1=°219_2=]187_0==187_1=+187_2=}221_0=^221_1=¨186_0=$186_1=£186_2=¤192_0=ù192_1=%220_0=*220_1=µ226_0=<227_1=>188_0=,188_1=?190_0=;190_1=.191_0=:191_1=/223_0=!223_1=§# Le pave numerique96_0=097_0=198_0=299_0=3100_0=4101_0=5102_0=6103_0=7104_0=8105_0=9111_0=/106_0=*109_0=-107_0=+110_0=.
ANNEXE 3 : Aide-Mémoire
AIDE-MÉMOIRE UTILISATION ROBOT-
SAISIE
Mécanisme généralL'exécution d'un «script» RobotSaisie s'exécute en 3 phases selon le schéma indiqué ci-dessous:
Phases Synoptique de la phase Fichiers du scénario
pour la phase
Fichiers généraux
Connexion <scénario>.cnx
RobotSaisieV4.properti
es (s'il existe sous
l'arborescence duscénario est choisi à laplace du fichier général)
clavier_FR.properties
RobotSaisieV4.properti
es
Boucle
n fois où n est le nombre delignes du fichier<scenario>.csv
<scénario>.properties
<scenario>.csv
RobotSaisieV4.properti
es (s'il existe sous
l'arborescence duscénario est choisi à laplace du fichier général)
clavier_FR.properties
RobotSaisieV4.properti
es
Phases Synoptique de la phase Fichiers du scénario
pour la phase
Fichiers généraux
Déconnexion
<scenario>.dcx
RobotSaisieV4.properti
es (s'il existe sous
l'arborescence duscénario est choisi à laplace du fichier général)
clavier_FR.properties
RobotSaisieV4.properti
es
Le fichier <scenario>.cnx contient les données et les contrôles nécessaires à la phase de connexion.
Le fichier <scenario>.properties contient les contrôles nécessaires à la phase itérative de boucle du
scénario
Le fichier <scenario.csv contient les données de la phase itérative de la boucle du scénario.
Le fichier <scenario>.dcx contient les données et les contrôles nécessaires à la phase de
déconnexion
Le fichier RobotSaisieV4.properties contient les paramètres de fonctionnement de RobotSaisie.
Voir plus loin l'explication des principaux paramètres
Le fichier clavier_FR.properties décrit les contrôles claviers d'un clavier français. Voir dans la
documentation comment rajouter un contrôle non encore décrit dans ce fichier.
Lancement de RobotSaisie
Le lancement se fait à l'aide d'un script RobotSaisieW.bat auquel on passe en paramètre le nom du
scénario.
Le lancement du scénario essai8 est donc :
.\RobotSaisieW.bat essai8
ou directement à travers le workbench.
