Repetición por elementos en un control de árbol utilizando el método getTestData

Este tema proporciona un ejemplo de utilización del método getTestData de Functional Tester para acceder programáticamente a los valores de las ramas de un control de árbol.

El siguiente ejemplo es una prueba contra la aplicación Classics Java:

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) 
	{
		//Start Classics Java Application
startApp("ClassicsJavaA");
		
		// Frame: ClassicsCD
		tree2().waitForExistence();
		
		//Display available test data types available from tree
		System.out.println ("Available Tree Data Types: " + tree2().getTestDataTypes());
		
		//Declare variables for tree
		ITestDataTree cdTree;
		ITestDataTreeNodes cdTreeNodes;
		ITestDataTreeNode[] cdTreeNode;

		//Variables to hold tree data
		cdTree = (ITestDataTree)tree2().getTestData("tree");
		cdTreeNodes = cdTree.getTreeNodes();
		cdTreeNode = cdTreeNodes.getRootNodes();

		//Print out total number of nodes
		System.out.println ("Tree Total Node Count: " + cdTreeNodes.getNodeCount());
		System.out.println ("Tree Root Node Count : " + cdTreeNodes.getRootNodeCount());

		//Iterate through tree branches; this is a recursive method.
		for (int i = 0;i<cdTreeNode.length;++i)
		showTree(cdTreeNode[i], 0);

		//Shut down Classics Java Application
		classicsJava(ANY,MAY_EXIT).close();
		}

		void showTree(ITestDataTreeNode node, int indent)
		{
		//Recursive method to print out tree nodes with proper indenting.

		//Determine number of tabs to use - to properly indent tree
		int tabCount = ( indent < tabs.length() ? indent :
		tabs.length() );

		//Print out node name + number of children
		System.out.println(tabs.substring(0, tabCount) + node.getNode() + " (" + node.getChildCount() + "children)" );

		//Determine if node has children; recursively call this same
		//method to print out child nodes.
		ITestDataTreeNode[] children = node.getChildren();
		int childCount = ( children != null ? children.length : 0 );
		for ( int i = 0; i < childCount; ++i )
		showTree(children[i], indent+1);
		}

		//String of tabs used to indent tree view
		final String tabs = "\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t";

}

En la primera pantalla de esta aplicación encontrará un componente Java Swing JTree, con un listado de cinco compositores. El siguiente nivel inferior presenta un listado con los CD disponibles del compositor seleccionado. El código de este ejemplo extrae los valores de todas las ramas del árbol y los muestra en la ventana de la consola.

El primer paso para extraer los datos consiste en utilizar el método getTestData para extraer los datos desde el control. Esto se efectúa con la sintaxis siguiente:

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

El paso siguiente consiste en crear una matriz que contenga todos los nodos del árbol. Esto se efectúa de la siguiente manera:

ITestDataTreeNodes cdTreeNodes;
ITestDataTreeNode[] cdTreeNode;

cdTreeNodes = cdTree.getTreeNodes();//Encapsulates the root
nodes.
cdTreeNode = cdTreeNodes.getRootNodes();;//Extracts actual
root nodes.

Tenga en cuenta de que se trata de un proceso de dos pasos. Primero, debe utilizar el método getTreeNodes para devolver un objeto TreeNodes. A continuación, puede llamar al método getRootNodes para extraer una matriz de los nodos raíz para el árbol.

Con los tres nodos en cuestión, puede utilizar la recurrencia para recorrer cada nodo para determinar su valor y el número de hijos directos que contiene. Esto se realiza con el método recurrente showTree. Un método recurrente es un método que se llama a sí mismo y que constituye una forma eficiente de recorrer una estructura de árbol. Para extraer el valor del nodo se utiliza el método getNode. Para extraer el número de hijos que contiene un nodo, se utiliza el método getChildCount. En el ejemplo se efectúa con el siguiente código:

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

Tenga en cuenta, que la codificación adicional que se suministra con el método showTree personalizado está previsto para habilitar una impresión formateada mediante tabuladores para indicar el sangrado del árbol.


Comentarios