Itération sur les éléments d'un contrôle d'arborescence à l'aide de la méthode getTestData

Cette rubrique fournit un exemple d'utilisation de la méthode getTestData de Functional Tester pour accéder à l'aide d'un programme aux valeurs des branches d'un contrôle d'arborescence.

L'application testée est l'exemple d'application Java fourni avec le produit, ClassicsCD (ClassicsJavaA) :

import resources.GetTreeDataExampleHelper;
import com.rational.test.ft.*;
import com.rational.test.ft.object.interfaces.*;
import com.rational.test.ft.object.interfaces.SAP.*;
import com.rational.test.ft.object.interfaces.siebel.*;
import com.rational.test.ft.script.*;
import com.rational.test.ft.value.*;
import com.rational.test.ft.vp.*;

/**
 * Description : Functional Test Script
 * @author Administrator
 */
public class GetTreeDataExample extends GetTreeDataExampleHelper
{
	/**
	 * Script Name   : GetTreeDataExample
	 * Generated     : Jul 14, 2006 4:46:31 PM
	 * Description   : Functional Test Script
	 * Original Host : WinNT Version 5.1  Build 2600 (S)
	 * 
	 * @since  2006/07/14
	 * @author Administrator
	 */
	public void testMain (Object[] args) 
	{
		//Démarrer l'application Java Classics
		startApp("ClassicsJavaA");
		
		// Fenêtre : ClassicsCD
		tree2().waitForExistence();
		
		//Afficher les types de données pouvant être testés dans l'arborescence
		System.out.println ("Available Tree Data Types: " + tree2().getTestDataTypes());
		
		//Déclarer des variables pour l'arborescence
		ITestDataTree cdTree;
		ITestDataTreeNodes cdTreeNodes;
		ITestDataTreeNode[] cdTreeNode;

		//Variables pour le stockage des données de l'arborescence
		cdTree = (ITestDataTree)tree2().getTestData("tree");
		cdTreeNodes = cdTree.getTreeNodes();
		cdTreeNode = cdTreeNodes.getRootNodes();

		//Afficher le nombre total de noeuds
		System.out.println ("Tree Total Node Count: " + cdTreeNodes.getNodeCount());
		System.out.println ("Tree Root Node Count : " + cdTreeNodes.getRootNodeCount());

		//Itérer sur les branches de l'arborescence ; il s'agit d'une méthode récursive.
		for (int i = 0;i<cdTreeNode.length;++i)
		showTree(cdTreeNode[i], 0);

		//Fermer l'application Java Classics
		classicsJava(ANY,MAY_EXIT).close();
		}

		void showTree(ITestDataTreeNode node, int indent)
		{
		//Méthode récursive pour afficher les noeuds de l'arborescence avec les retraits (indentations) appropriés.

		//Déterminer le nombre de tabulations à utiliser pour indenter correctement l'arborescence
		int tabCount = ( indent < tabs.length() ? indent :
		tabs.length() );

		//Afficher le nom du noeud et le nombre de ses enfants
		System.out.println(tabs.substring(0, tabCount) + node.getNode() + " (" + node.getChildCount() + "children)" );

		//Déterminer si le noeud a des enfants ; appeler récursivement cette même
		//méthode pour afficher les noeuds enfant.
		ITestDataTreeNode[] children = node.getChildren();
		int childCount = ( children != null ? children.length : 0 );
		for ( int i = 0; i < childCount; ++i )
		showTree(children[i], indent+1);
		}

		//Chaîne de tabulations utilisée pour indenter la vue de l'arborescence
		final String tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";

}

Sur le premier écran de l'application testée figure un composant Java Swing JTree qui, au premier niveau, répertorie cinq compositeurs classiques. Au niveau suivant de l'arborescence figure la liste des oeuvres sur CD du compositeur sélectionné (et qui peuvent être commandés par l'utilisateur). Le code de cet exemple de script lit les valeurs de toutes les branches de l'arbre et les affiche dans la console.

La première étape consiste à utiliser la méthode getTestData pour extraire les données du contrôle. La syntaxe suivante est utilisée à cet effet :

ITestDataTree cdTree;  
cdTree = (ITestDataTree)tree2().getTestData("tree");

L'étape suivante consiste à créer un tableau (array) contenant tous les noeuds de l'arborescence. Cette opération est réalisée comme suit :

ITestDataTreeNodes cdTreeNodes;
ITestDataTreeNode[] cdTreeNode;

cdTreeNodes = cdTree.getTreeNodes();//Comprend les noeuds
racine.
cdTreeNode = cdTreeNodes.getRootNodes();;//Extrait les noeuds
racines proprement dits.

Notez que ce processus comprend deux étapes. On utilise d'abord la méthode getTreeNodes pour renvoyer un objet TreeNodes. On appelle ensuite la méthode getRootNodes sur cet objet pour obtenir un tableau constitué des noeuds racines de l'arborescence.

Une fois les noeuds disponibles, on peut les parcourir un à un pour déterminer leur valeur et le nombre d'enfants directs qu'ils contiennent. On utilise pour cela la méthode récursive showTree. Une méthode récursive est une méthode qui s'appelle elle-même. Il s'agit d'un moyen efficace de parcourir une structure arborescente. Pour lire la valeur de chaque noeud, on a recours à la méthode getNode. Pour obtenir le nombre d'enfants du noeud, on utilise la méthode getChildCount. La syntaxe suivante est utilisée à cet effet :

System.out.println(tabs.substring(0, tabCount) + node.getNode()+" (" + node.getChildCount() + " children)"); 

Notez que le codage additionnel fourni dans la méthode showTree personnalisée a pour but de mettre en forme la présentation de l'arborescence. On utilise à cet effet des tabulations pour refléter le retrait des éléments.


Retour d'informations