- Test Script Synchronization
- Placing a Generic Delay in Your Script
- Waiting for Test Objects to Come into Existence
- Timing How Long Something Takes to Execute in a Script
- Working with Test Objects
- Working with the Clipboard Object
- Viewing an Objects Properties
- Retrieving All Properties of a Test Object
- Retrieving the Value of a Single Property
- Programmatically Retrieving Data from an Object in My Application
- Determining a Test Objects Valid Test Data Type Arguments to getTestData()
- Using getTestData to Extract Data from a Text Field
- Using getTestData to Extract Data from a List
- Using getTestData() to Read Data in a Table
- Using getTestData() to Extract Data from a Tree
- Obtaining Data from a Test Object That the Rational Functional Tester Verification Point Wizard Does Not Capture
- Creating a Custom Verification Point
- Changing the Value of a Test Objects Property
- Evolving Custom Scripting into Reusable Methods
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
Viewing an Object’s Properties
Rational Functional Tester has a useful (and often overlooked) utility called the Test Object Inspector that you can use to examine a wealth of information about test objects (including properties). No coding is required to use the Inspector. It is a design-time tool that can often be used to gather information you need to write your own code. It’s powerful because it shows you almost everything that you can manipulate in the test object through Rational Functional Tester.
To launch the Inspector, click Run > Test Object Inspector (in Eclipse) or Tools > Test Object Inspector (in Visual Studio). After the Inspector displays, by default it remains on top of all windows on your Desktop. As you move your mouse over objects, the Inspector captures information and displays it in the Inspector window. To inspect any object on your desktop, simply hover over the object and press the Pause key on your keyboard. This tells the Inspector to freeze with the information currently captured, and enables you to move your mouse and not lose the information currently displayed in the Inspector window.
After you pause it, you can view information about the test object. The Inspector can show five broad categories of information: Parent Hierarchy, Inheritance Hierarchy, Properties, NonValue Properties, and Method information.
To select what you want the Inspector to display, press the corresponding button on the toolbar or make your selection under the Inspector’s Show menu. In addition to these broad categories, there are options that you can turn on and off under the Options menu. The following examines five examples:
-
Parent Hierarchy—Shows the hierarchical path from the test object to the top-level window. For example, if you inspected the Google Search button on www.google.com (http://www.google.com), the Inspector shows what is displayed in Figure 3.13.
The Inspector displays the same recognition information (hierarchy and recognition property names and current values) that the object map would store for the button, except that the tree is upside down (the browser window is the bottom, not at the top, as in the object map) and the hierarchy is flattened (there are no indentations).You might turn on this option when viewing a test object’s parent hierarchy that does a full disclosure of sorts. This option expands what’s displayed in the Parent Hierarchy to include nonmappable objects. To turn this option on, toggle Hide not Mappable under the Options menu. Nonmappable objects are objects that RFT does not think are interesting and does not, therefore, add to the object map (RFT doesn’t record any actions against nonmappable objects). However, sometimes you want to know about nonmappable objects. In such situations, turning on this option is useful. Figure 3.14 shows the Parent Hierarchy for the Google Search button.
Without displaying nonmappable objects, the parent of the button is the HTML table; when you include nonmappable objects, you see that the parent (the real parent in a sense) is the TD HTML element. To differentiate between these two views of test object parentage, you say that the table is the button’s mappable parent and the TD is its nonmappable parent. The RFT API differentiates between mappable and nonmappable parents and children.
-
Inheritance Hierarchy—Shows class inheritance hierarchy of the test object’s class. This option does not apply the HTML test objects. Figure 3.15 shows the inheritance hierarchy for the Place Order button in Classics.
Here, the Inspector shows that the (Java) class of the button is javax.swing.JButton, which inherits from AbstractButton, which inherits from JComponent, and so on up to Object, the root class of all classes in Java. -
Properties—Shows all the test object’s value properties (property names and values). Figure 3.16 shows what you get when you examine the properties of the Place Order button in Classics.
-
NonValueProperties—Shows all the test object’s nonvalue property names and each nonvalue property’s data type. Using the Place Order button, the Inspector shows the following nonvalue properties (displayed in Figure 3.17).
-
Method Information—Shows all the methods that can be invoked directly on the test object via RFT’s invoke() method (which we cover in Chapter 10). The methods are grouped by the test object class’ inheritance chain. An example of this is shown in Figure 3.18.
)
)
)
)
)
)
To the right of each method name, the Inspector shows the method’s JNI signature (argument list and return type).
What is the difference between a value property and a nonvalue property? A value property is a property whose value Rational Functional Tester can reconstruct in its own JVM and store and compare it to other values in another context. There is a practical application of this: When you perform a Properties verification point, for example, Rational Functional Tester captures and must then store (as a baseline) the values of the properties that are being verified. When the verification point is executed, Rational Functional Tester must know how to compare the baseline values with the actual values. The properties Rational Functional Tester can manipulate in this manner are referred to collectively as value properties. Properties whose values Rational Functional Tester does not know how to store and compare are called nonvalue properties.
If you look at the list of value properties, you can see that the value of each property is either a String (actionCommand), boolean (enabled), numeric (alignment), or a Java class that consists of numeric fields (Rectangle and Color). These values can easily be restructured, stored, and compared in another context (RFT’s JVM or a baseline VP file).
The nonvalue properties, on the other hand, are different in nature. In the nonvalue property list, you see properties such as graphicsConfiguration, icon, and cursor. It’s not difficult to appreciate that it is difficult (at best) for RFT to store the value of a Cursor object or any of the other nonvalue properties. Both value and nonvalue property values are available to you through coding.