You are on page 1of 22

1: How to retrieve the value of an object property programmatically?

In the following example we use the getProperty method to find out as to whether a label contains a success message. If it contains the success message, the OK button will get clicked. If it doesn't contains the success message, the Cancel button will get clicked. if("SUCCESS".equals(dialog_htmlDialogStatic(). getProperty(".text"))) { dialog_htmlDialogButtonOK().click(); } else { dialog_htmlDialogButtonCancel().click(); }

Tutorial - 2: How do we use an anchor to locate a particular object using RFT?


This short tutorial describes a method of using an anchor to locate a particular object in RFT. Use of an anchor is useful in pin pointing a test object, which normally RFT finds it difficult to differentiate between two similar objects during playback. This happens usually when two browsers or instances of the same application are open simultaneously. We can identify the browser and the instances of the application by using a TestObject reference. Running more than one instance of an application simultaneously during playback will result in ambiguity about the target of commands like object() or click(). To solve this problem, we can use "ProcessTestObject" when we call the "startApp" command as described below. ProcessTestObject pto1 = startApp("ApplicationOne"); ProcessTestObject pto2 = startApp("ApplicationTwo"); object(pto1, DEFAULT).click(); In the above example, the "ProcessTestObject" functions as an anchor to locate the desired application.

Tutorial - 3: What steps are needed to be performed for setting up the RFT?

This short tutorial describes various steps required for setting up the RFT. Use the Java Runtime Environment (JRE) which gets installed while loading RFT and gets enabled for testing Java applications. Before starting recording of any script following steps are essential: Step - 1: Setting up the logging options. RFT provides many logging options. Here we can use the HTML log. a) To verify that HTML logging is set, click "Window" > "Preferences". b) In the left pane of the Preferences window, expand "Functional Test" > then "Playback" > click "Logging". c) Verify that the Use "Default" check box is selected and that html appears in the "Log type" field. d) Click "OK". These setting of Step -1, shall open the HTML log automatically after playing back of a script. Step - 2: Creation of a Functional Tester project a) In the Functional Tester menu, click "File" > "New" > "Functional Test Project". b) Provide a logical "Project name" without any spaces for example - Testtutorial. c) Provide a logical "Project location" for example - C:\Testproject. This will create a new folder. d) If the source control option is available, do not select "Add the project to Source Control". e) If the associate project option is available, do not select "Associate the Functional Test Project with current Rational Project". f) Click "Finish". The Testtutorial project is now visible in the Functional Test Projects view, which is the left pane in the RFT perspective.

Tutorial - 4: How do we record a script using Rational Functional Tester - RFT?


This tutorial describes a method of recording a script in Rational Functional Tester RFT from IBM. Step - 1: Setting of the recording options. Click "Window" > "Preferences" to access the RFT options. In the tree hierarchy, click the plus sign (+) on the side of "Functional Tester " to expand the preferences. Define the desired recording options. Close the preferences after completion. Step - 2: Click the "Record a Functional Test Script" button or click "File" > "New" > "Functional Test Script Using Recorder". The "Record a Functional Test Script" dialog box opens.

Step - 3: In the "Record a Functional Test Script" dialog box, select the project to which the new script shall be associated. Provide a name for the new script. The script name should not contain space or special characters like : $ \ / : & * ? " < > | # % Step - 4: In case it is required to keep the script under source control, Check mark "Add the script to Source Control". This will add the script to "ClearCase", however the script shall remain checked out and we are able to make changes in it. Step - 5: a) Click "Finish" to open the Recording Monitor & start the recording. RFT will create a local object map for our script by default. b) Click "Next" to open the "Select Script Assets page", In case we wish to use a different test object map, helper superclass, or test datapool. c) From the "Select Script Assets page", we can define the datapool record selection order and we can also change the datapool associated with the script. Step - 6: Upon opening of the Recording Monitor and starting of the recording after Step -5, Click the "Display Help" icon for getting information on the toolbar buttons and regarding operation of the monitor. Step - 7: Click the "Start Application" button on the "Recording" toolbar to start the test application. Perform the desired actions on the running application. Step - 8: a) For recording a verification point, identify the object in the application. b) Click anywhere in the application window or the dialog box. c) Click the "Insert Verification Point or Action Command" button. Step - 9: Click the "Insert Script Support Commands" button for inserting any special features into the script. Features can be a call script command, log entry, timer, script delay command, or comment etc. Step - 10: Close the application, if we want closing of the application to be part of the script. Step - 11: Click the "Stop Recording" button to finish the recording. This process writes the script and object map into the project directory. RFT window gets restored and the recorded script gets displayed.

Tutorial - 5: How do we record data verification point for test objects using RFT?
This short tutorial describes a method of recording a data verification points for test objects using RFT. The purpose of creating verification points is to verify that a particular desired action has taken place, or to verify the state of an object.

Step - 1: Start the Recording:

a) In RFT Java Scripting, click the "Record a Functional Tester Script" button on the Functional Tester toolbar or the "File" > "New" > "Functional Tester Script Using Recorder" menu command to start recording a script. b) In RFT VB.NET Scripting, click the "Record a Functional Tester Script" button on the Functional Tester toolbar or the "File" > "New" > "Add Script Using Recorder" menu command to start recording a script. Step - 2: Start the test application by clicking the "Start Application" button in the RFT Recording Monitor. Step - 3: Locate the list in the application which is intended to be tested. Step - 4: In the RFT Recording Monitor, click the "Insert Verification Point or Action Command" button on the toolbar. Step - 5: On the "Select an Object" page of the Verification Point and Action Wizard, use the Object Finder to select the list in the application intended to be tested. To test the entire list, we can select any item in the list. Step - 6: After selecting the list, we can see that one of the values shown on the Object recognition properties grid is "list." Verify this "List" and click Next. Step - 7: Go to the "Select an Action" page. Select the first option on the page i.e. "Perform Data Verification Point" option. Step - 8: In the "Data Value" field, select either of the following: a) "List Elements" - to test the contents of the entire list. or b) "Selected List Elements" test - to test only the items which are selected. Step - 9: In the "Verification Point Name" field, accept the default suggestion, or provide a new name of own choice. Step - 10: Use the "Include Retry Parameters" to set a retry time for a verification point during playback to check for its existence. This retry option shall be helpful to us when playback will fail to find the verification point in the application. Step - 11: After accepting or editing the above fields, click "Next" to continue. Step - 12: After viewing or editing the list data, click "Finish" button. This will record the verification point & it will be added to the script. Step - 13: Finish the recording by clicking the "Stop Recording" button on the "Recording Monitor" toolbar. We can open the Verification Point Editor any time to edit the data recorded earlier.

Tutorial - 5: How do we record data verification point for test objects using RFT?

This short tutorial describes a method of recording a data verification points for test objects using RFT. The purpose of creating verification points is to verify that a particular desired action has taken place, or to verify the state of an object. Step - 1: Start the Recording:

a) In RFT Java Scripting, click the "Record a Functional Tester Script" button on the Functional Tester toolbar or the "File" > "New" > "Functional Tester Script Using Recorder" menu command to start recording a script. b) In RFT VB.NET Scripting, click the "Record a Functional Tester Script" button on the Functional Tester toolbar or the "File" > "New" > "Add Script Using Recorder" menu command to start recording a script. Step - 2: Start the test application by clicking the "Start Application" button in the RFT Recording Monitor. Step - 3: Locate the list in the application which is intended to be tested. Step - 4: In the RFT Recording Monitor, click the "Insert Verification Point or Action Command" button on the toolbar. Step - 5: On the "Select an Object" page of the Verification Point and Action Wizard, use the Object Finder to select the list in the application intended to be tested. To test the entire list, we can select any item in the list. Step - 6: After selecting the list, we can see that one of the values shown on the Object recognition properties grid is "list." Verify this "List" and click Next. Step - 7: Go to the "Select an Action" page. Select the first option on the page i.e. "Perform Data Verification Point" option. Step - 8: In the "Data Value" field, select either of the following: a) "List Elements" - to test the contents of the entire list. or b) "Selected List Elements" test - to test only the items which are selected. Step - 9: In the "Verification Point Name" field, accept the default suggestion, or provide a new name of own choice. Step - 10: Use the "Include Retry Parameters" to set a retry time for a verification point during playback to check for its existence. This retry option shall be helpful to us when playback will fail to find the verification point in the application. Step - 11: After accepting or editing the above fields, click "Next" to continue. Step - 12: After viewing or editing the list data, click "Finish" button. This will record the verification point & it will be added to the script.

Step - 13: Finish the recording by clicking the "Stop Recording" button on the "Recording Monitor" toolbar. We can open the Verification Point Editor any time to edit the data recorded earlier.

Tutorial - 6: How can we create a new RFT script Manually i.e. without Recording?
There is an alternative to recording, wherein we can manually create a script to enter the Java code for use in RFT. When we create a new script, the RFT includes import statements for all the files required to compile the script and comments. These files contain important archiving information. By default, RFT uses the script name as the class name and sets up testMain, where we can add various commands to include in the script. This short tutorial describes various steps to create a new RFT script manually as a substitute for recording: Step 1: Click the "Create an Empty Functional Tester Script" button on the RFT toolbar Alternatively Click "File" > "New" > "Empty Functional Tester Script" on the RFT menu. Step 2: In the "Create an empty Functional Tester script dialog box", enter or select a folder for the script and type a name in the "Script name" field. The script name must follow the naming conventions defined for Java class names. Step 3: Apply the check mark against "Add the script to Source Control" in case we want to keep the script under source control. Step 4: Here we have two options to create a local test object map for the script: Option 1: Click "Next" for using a different "Test Object Map", "Helper Superclass", or "Test Datapool". Chose the desired test assets out the following choices offered in the "Select Script Assets page", and click "Finish": # Select and set a default test object map. # Select and set a default helper Superclass. # Select a test Datapool. # Select a Datapool record selection order. Option 2: Click "Finish" for creating a new script. This step creates a local test object map for our script and displays the script in the Projects View.

Step 5: To put the script under source control: 1) Do Right-click over the new script in the Projects View 2) Click "Team" 3) Click "Check In". 4) Click "Finish" in the "Check In" dialog box. Step 6: Start adding the desired code to the script. For adding the desired objects and methods to the script we can use the Test Object Map. We can add special features like call script command, log entry, timer, script delay, or comment to the script. This can be done by clicking the "Insert Recording into Active Functional Tester Script" button available on the toolbar of RFT. Then on the Recording toolbar, click the "Insert Script Support Commands button". We can also use the buttons on the Recording toolbar for starting an application from the script or for creating a verification point.

Tutorial - 7: How to do recording in a RFT script which is already existing?


This short tutorial presents a simple method to do recording in an already existing RFT script. Invariably we come across a situation that we need to do additional recording in an already existing script. It is quite simple in RFT. The only thing we need to do is to bring the cursor at the desired location in the existing script & start the recording from there onward. The process of such recording is no different from the fresh recording. All features like starting the applications, inserting the verification points, and adding the script support functions are available as usual. Following are the steps to begin recording in an existing RFT script: Step 1: Bring the cursor to a location in the existing script from where onwards we intend to start the recording. Step 2: Next step is to open the "Recording Monitor" and starts the recording. This can be done in either of the following two ways: Method 1: Click "Script" > "Insert Recording" from the In the RFT menu. Method 2: Click the "Insert Recording into Active Functional Test Script" button available In the RFT toolbar. Step 3: Next step involves starting the test application. This can be done by clicking the "Start Application" button on the "Recording" toolbar. Step 4: Now we can perform all desired actions over the application.

Step 5: We can record a verification point as well at this stage. This can be done by locating the object in the application desired to be tested. A verification point can be inserted by clicking the "Insert Verification Point or Action Command" button. Step 6: We can insert any desired feature at this stage. The features like a call script command, log entry, timer, script delay command, or comment into the script can be added by clicking the "Insert Script Support Commands" button. Step 7: We can terminate the application, in case closing of the application is desired to be a part of the script. Step 8: We can finish the recording operation by clicking the "Stop Recording" button. This process restores the RFT window and displays the script

Tutorial - 8: How to use Verification Point Comparator Utility of RFT for comparing the Verification Point Data?
We use the "Verification Point Comparator" for comparing the verification point data after playing back a script with a verification point and to update the baseline file. In case the verification point happens to fail, the "Comparator" displays both types of values i.e. the expected and actual ones, so that we can draw a comparison. This provides us adequate information for updating the baseline file with the actual values from the actual file. The Comparator can be opened by either of the following methods: 1) Double-clicking the verification point in the RFT log in the "TestManager". 2) Clicking the View Results link in the RFT HTML log. The Title of the Verification point gets displayed in the "Comparator" banner. This short tutorial presents a simple method of using Verification Point Comparator Utility of RFT for comparing the verification point data Following are the steps to compare and update the verification point data using the Comparator: Step 1: Record a script in RFT and ensure that it must have at least one verification point. Step 2: Play back the script containing the verification point on a new build of the application under test. Step 3: View the log of the concerned playback after it gets finished. Step 4: Open the "Comparator" from the log & view the verification point by the following. a) In case of use of the TestManager log: Double click the verification point in the "Event Type" column. Expanding the Script Start command can enable us to see the verification point. b) In case of use of the HTML log: Click the "View Results" link. At this stage we are likely to get a Java plug-in error. Thus to avoid this error, ensure that the Java plug-in is properly configured. The Verification Point Comparator opens to display that verification point.

Step 5: We may encounter failure of verification points. The failed verification points can be handled by: a) In case of failure of one verification point while using log in RFT Java Scripting: Select the log in the RFT Projects view. Then, right-click the log, and click "Failed Verification Points". b) In case of failure of one verification point while using log in RFT VB.NET Scripting: Select the log in the Solution Explorer, right-click the log, and click "Failed Verification Points".. c) In case of failure of multiple verification points while using log: The wizard of Results for Verification Points shall open. Click the desired failed verification point in the list and click "View Results" or "Finish". The Verification Point Comparator opens to display the concerned verification point. The Comparator displays the expected and actual data values. The difference between the expected and actual data values is that we performed the test with some expected values. However the actual values were captured in the application during the playback. For failed verification points, the differences are indicated in red. Step 6: Understanding of display structure for expected versus actual values: a) For Properties, List, Table and data Text type verification points: The expected values are displayed on the left and the actual values are displayed on the right: b) For Menu Hierarchy Properties and Tree Hierarchy type verification points: The expected and actual values are shown contiguously. The expected values of the differences are shown in Red, and the actual values of the differences are shown below them in Green. Step 7: View the two data files to draw a comparison of differences between the expected and actual files. By close analysis of the differences in the Comparator, we can find out if they are intentional changes to the application or are real defects. For navigating through the differences, we can use the navigation buttons on the toolbar above the data display. Step 8: We may need to edit the baseline file to update the information for future playbacks. For this we need to load the baseline file. Click "File" > "Baseline" or click the button "Load Baseline to Edit" available on the toolbar. The baseline file replaces the expected file on the left side of the display. Step 9: Editing of items in the data: a) For individual items in the data: We can edit them in the baseline (left) column of the display. Click "Save", after completion. b) For a Text type verification point: Click "Edit Text" to launch the text editor to make the changes. c) For all other verification point types: We can edit directly in the baseline data display. Step 10: Replacement of Baseline file:

a) For a properties verification point, updating of the baseline value is to be done in case difference is observed in the baseline value and the actual value for a particular property. In the Verification Point Comparator, Right-click the property where the values are observed to be different, and click "Replace Baseline on Current Selection". b) In case all the differences reflect intentional changes to the application under test, and we want to update the baseline to reflect the changes, we need to use the "Replace Baseline with Actual Value" toolbar button to replace the entire baseline file. c) In case we have made any individual changes to the baseline data file without the use of "Replace Baseline with Actual Value" command, click File > "Save" to save the changes. Step 11: We can come out of the "Verification Point Comparator" after finishing the comparing and updating operation on the verification point data, click "File" > "Exit" to exit the Verification Point Comparator

Tutorial - 9: How to create a Properties Verification Point in RFT for testing the properties of an object?
Brief Introduction - How a Properties Verification Point operate: The purpose of a Properties verification point is use in testing the properties of an object in our application. When a verification point is recorded, a baseline of the object's properties gets created. Thereafter every time the script is played back, the properties will be compared to confirm if any changes have taken place, may be intentionally or even unintentionally. With the help of Properties verification point we can identify the presence of potential defects in our application. This short tutorial presents a simple method of creating a Properties Verification Point in RFT for testing the properties of an object Steps to create a Properties Verification Point are as under: Step 1: Starting of the recording operation of script: a) For RFT Java Scripting: Click the "Record a Functional Tester Script" button on the RFT toolbar or the "File" > "New" > "Functional Tester Script Using Recorder" menu command. b) For RFT VB.NET Scripting: Click the "Record a Functional Tester Script" button on the RFT toolbar or the "File" > "New" > "Add Script Using Recorder" menu command. Step 2: In the RFT Recording Monitor, click the "Start Application" button to start the test application. Step 3: Locate the object in the application, which we want to test. Step 4: In the Functional Tester Recording Monitor, click the "Insert Verification Point or Action Command" button on the toolbar.

Step 5: Picking up the object in the application: The objects in our application can be picked up on the "Select an Object page" of the Verification Point and Action wizard, by either of the following three selection methods. Method 1: Object Finder Tool method: For selecting an object and all descendents of the object, select one object, or select an object and the immediate children of an object. Method 2: Test Object Browser method: For browsing for the object that we want to select. The browser displays a hierarchical tree of objects in our application. The top level shows any applications we are running. Under each top level, RFT displays the object hierarchy within that application. It is a dynamic view of the currently available objects. Method 3: Time Delayed method: For selecting pop-up objects, like menus. This method uses the Object Finder tool, but enables us to set a delay, which gives us time to reach an object which requires clicking on other objects first. Step 6: Advancement to the next page in the Verification Point and Action wizard: On the Select an Object page, the check box "After selecting an object advance to next page" is selected by default. This causes automatic advancement to the next page in the Verification Point and Action wizard. Alternatively If the check box "After selecting an object advance to next page" is deselected, we need to manually click "Next" to move to the next page. Step 7: Selection of various options for properties verification point: a) On the "Select an Action" page, click the "Perform Properties Verification Point" option, and then click "Next". b) Use either of the following four options like: 1) "Include Children" In case we want to include the properties of the object's child objects (in case it has child objects). 2) "None" For testing the object only without children. 3) "Immediate" For testing the object and any immediate children present at one level down) 4) "All" For testing the object including all of its children down the entire hierarchy. Step 8: Providing a logical name to the Verification Point: Under "Verification Point Name", accept the suggested default, or type a new name in the box. The new name if any must be in accordance with standard Java naming conventions. Step 9: Selection of properties type: Choose whether to use standard property or Nonstandard properties types. Standard properties are available across platforms and browsers; whereas nonstandard properties can include platform-specific properties.

Step 10: Setting of retry time for the verification point during the playback:

The retry option is helpful when playback does not find the verification point in the application & retry option checks the existence of the verification point. a) We use the "Include Retry Parameters" for setting the retry time for the verification point during playback. We can either use the default values, or set our own values for the "Maximum Retry Time" & "Retry Interval". Here by default RFT will check for the existence of the verification point in the application every 2 seconds, for up to 20 seconds. b) The value set under "Maximum Retry Time" indicates the maximum number of seconds RFT will retry for the verification point to appear in the application during playback. c) The value set under "Retry Interval" indicates the number of seconds between times that RFT will check for the verification point during the wait period.

d) Click "Finish", to write the retry for verification point into the script, which will take place on future playbacks. Step 11: Editing the properties data: (Optional step) We need not test each & every property of the test object every time. Hence it is better to just test the specific set of properties we want while using a Properties verification point. a) The test object's properties and their values are available for editing in a tree table format on the "Verification Point Data" page. b) Only those properties can be edited which happened to be tested. We can edit the properties in the "Property" column, and can edit the property values in the "Value" column. c) Making a selection of object properties by check marking them for the test: # By default, all properties appear with no checkmark meaning thereby they will not be tested. # We need to apply the check mark against the selected properties desired to be tested. # Check marked properties will be tested each time we play back a script with this verification point. # We can select all properties in the list by clicking the "Check All" toolbar button above the grid. # We can use the "Uncheck All" button to clear the selection of all the properties. # To edit a value, double-click the tree table cell. That particular cell becomes editable. We can click outside the cell, which causes the edit to take effect. # In the case of the color property, we can edit the color value from the Color Chooser available to us. Step 12: Using a Datapool reference in place of a literal value for a property verification point: a) In the "Property" column, select a property, right-click, and then click "Convert Value to Datapool Reference". This will open The Datapool Reference Converter dialog box.

b) Type a new name for the Datapool variable or click the "Datapool Variable" arrow to select the variable that we want the verification point to reference in the Datapool c) Optionally, place a check mark on the "Add value to new record in Datapool" check box to add the value of the verification point to a new record row in the Datapool. d) Click "OK". Step 13: Click "Finish" to complete the process of recording & adding the verification point to the script. Stop the recording by clicking the "Stop Recording" button on the "Monitor" toolbar.

Tutorial - 11: How to Data Drive a Test Script using IBM - RFT?
This article presents a simple method of data driving IBM - RFT Test Script Steps for data driving a script are as under: Step 1: Creation of a Project: Project is the first & foremost workbench required to store the test assets which are needed for testing any application. Step 2: Beginning of the test script recording: Involves two steps like: a) Choice of Datapool record selection order: While playing back, the test script accesses various records in the datapool either sequentially or randomly. Thus choice out of these two options is done from the "Datapool Record Selection Order" box from the Select Script Assets dialog box. # Sequential order: Records are accessed by the test script in a sequential order as they appear in the Datapool. # Random order: Every record gets accessed by the test script randomly once from the Datapool. b) Finish the selections: Click "Finish" to minimize the Functional Tester window and launching the Recording Monitor. Step 3: Navigation across the application to a point desired to be data driven: # Click "Start Application" on the Recording toolbar. # Now do necessary actions across the application as desired to be recorded in the test script. Step 4: Data Driving the test: a) Opening of the Insert Data Driven Actions page after halting the recording of the test script. To do this; click "Insert Data Driven Commands" on the "Recording" toolbar, b) Key in the initial values which are desired to be seen in the Datapool in the fields required to be data driven in our application under test. While recording is halted, we avoid recording of unwanted actions in the test script by populating such fields. Step 5: Selecting the test objects: Under "Populate then Select Test Objects" select the test objects through either of the two methods:

Method 1: "Press and drag hand to select test objects" is used to select an object and all the descendents of the selected object. This is the most common and direct method of selecting an object. Method 2: For opening the Select Object to Data Drive page, "Use selection wizard to select test objects". To do this click on the "Drag Hand Selection" method with its options, alternatively click on the "Test Object Browser" method. Step 6: In case we had opted for method 1 under Step 5 above i.e. "Press and drag hand to select test objects" a) Use the mouse to drag the hand shaped, "Object Finder tool", to the object in the application which is desired to be selected. RFT automatically outlines this object with a red border. b) Now release the mouse button. The Data Drive Actions page shall open now. The information about the objects selected by us appears under the DataDriven Commands table. For viewing the line of the code inserted by RFT in our test script, we need to place the mouse pointer over a row in this table for data-driving our application. Step 7: In case we had opted for method 2 under Step 5 above i.e. "Use selection wizard to select test objects", click on "Selection method" arrow for making a selection out of either of the further two methods: Method A: "Drag Hand Selection" method is used to include only the selected object, the selected object and the immediate children of the selected object, or to include the selected object and all descendents of the selected object. Method B: "Test Object Browser" method is used to browse for the object desired to be selected. Step 8: In case we had opted for method A under Step 7 above i.e. "Drag Hand Selection" method a) Select or clear the option "After selecting an object advance to the next page". b) Use the mouse to drag the hand shaped Object Finder tool, to the object desired to be selected in the application. RFT automatically outlines this object with a red border. c) Release the mouse button. d) Click on "Next" if we opt for not selecting the option "After selecting an object advance to next page". e) Click on one of the following options: # "Just the selected object" # "Include the immediate children of the selected object" # "Include all descendents of the selected object" Step 9: In case we had opted for method B under Step 7 above i.e. "Test Object Browser" method

a) Browse the object tree to find the object required to be data-driven. b) Click on the part of the tree required to be selected. Then Click "Next". c) Click on one of the following options. # "Just the selected object" # "Include the immediate children of the selected object" # "Include all descendents of the selected object" d) Click "Finish". The Insert Data Driven Actions page opens & presents all the information filled in under "Data Driven Commands" and "Selected Command Description". Step 10: Click "OK" to finish the data-driving process for the script. This closes the "Insert Data Driven Actions" page and RFT presents a Datapool containing all the data gathered from the application. Step 11: Perform all other actions in the application, which we want to record. The actions can be like: Recording a verification point or inserting desired script support functions into the script such as such as a call script command, log entry, timer, script delay command, or comment etc. Step 12: Close the application, if we want closing of the application to be part of the script. Step 13: Click on "Stop Recording" on the "Recording" toolbar, to append all the recorded Information to the test script and update the Datapool with new variables and associated initial values. RFT window opens and the recorded script gets displayed in the editor window.

Tutorial - 12 : How to Create a Datapool using IBM Rational Functional Tester RFT
This article presents a simple method of creating a Datapool using IBM - RFT Brief Introduction to Datapools: A datapool is a test dataset, a collection of related data records which supplies realistic data values to the variables in a test script during test script playback. We can create data from scratch or import existing data into a new datapool from another RFT datapool, an IBM Rational TestManager datapool, or a .csv file. Rules for working with datapools: 1) When we import data, we ensure that we import the data into the same RFT project as the test scripts that access the data. 2) If we want to import data from a TestManager datapool, we need to first associate a RFT project with a Rational project to use the TestManager datapool.

Steps for Creating a Datapool are as under: Step - 1: Click "Create a Test Datapool". Step - 2: Applicable for RFT - Java Scripting: 2a) Either type the path to the folder we want or use the navigation tools (" Home", "Back", and "Go Into") to select the path. 2b) Type the name of the new datapool. 2c) If we want to create the RFT project in a ClearCase directory, optionally, select "Add the datapool to ClearCase". 2d) Next use either of the following steps according to need: # To create an empty datapool, if there is a filename in the "Import From" list, select the filename and delete it, and then click "Finish". # To import data into the datapool, click "Next", and then proceed to Step - 4. Step - 3: Applicable for RFT - VB.NET Scripting: 3a) Type the name of the new datapool. 3b) Either type the path to the desired folder or click "Browse" to browse to the path and folder. 3c) Click "Open". 3d) If we want to create the RFT project in a ClearCase VOB, we can add the datapool to ClearCase after creating it. 3e) Next use either of the following steps according to need: # To create an empty datapool, if there is a filename in the "Import From" list, select the filename and delete it, and then click "Finish". # To import data into the datapool, go to the next step. Step - 4: Importing of Data: To import data from a RFT or IBM Rational TestManager datapool, or from a .csv file take one of the following steps: # To import a .csv file: 4a) Type the path and filename of an existing .csv file, click the "Import From" arrow to select from a list of ten recently imported files, or click "Browse" to select the path and filename. 4b) Type one to three field separator characters to use in the file we want to import. Remember that RFT must use the same field separator character as the one used in the .csv file from which we are importing data. If we are not sure which field separator characters to specify, use a text editor to open the .csv file and see the field separator characters that are used.

4c) "Select First Record is Variable Information" to make the first row of the imported data, the header of a new datapool. If we clear "First Record is Variable Information", the first record in the .csv file is imported as data and the headers use the default headers, such as data0, data1, etc. "First Record is Variable Information" is unavailable if the file we select to import is not a .csv file or not a TestManager file. # To import a RFT datapool: 4a) Click the "Import From" arrow to display a list of ten recently imported files, and then select a RFT datapool from the list. 4b) Type the path and filename of an existing RFT datapool. 4c) Click "Browse" to select the path and filename of an existing RFT Datapool. # To import a TestManager datapool: Click "Browse TM" to select the path and filename of the TestManager datapool we want to import. RFT automatically extracts the header information from the associated TestManager .spc file. Step - 5: Click "Finish". A newly created datapool gets displayed.

Tutorial - 13 : How to call a script from a IBM RFT - Functional Test Script
This article presents a simple method of calling a script from IBM - RFT Functional Test Script While recording or editing a RFT script, we can insert a call to a previously recorded script. This allows us to avoid repeatedly recording similar actions on the application-under-test by taking advantage of scripts that already exist. Steps to call a script from a RFT script are as under: Step - 1: In case of recording: click the "Insert Script Support Commands" button on the Recording Monitor toolbar. Step - 2: In case of editing: 2a) Position the pointer in the script where we want to place the callScript command. 2b) Click the "Insert Recording into Active Functional Tester Script" button on the RFT toolbar. 2c) Click the "Insert Script Support Commands" button on the Recording Monitor toolbar. Step - 3: Click the "Call Script tab" in the Script Support Functions dialog box. Step - 4: In the "Script Name" field, select from the list the name of the script we want to call or enter the name. Step - 5: In the "Datapool Iterator Count" field, do either of the following according to the need

# Type or select the number of records in the datapool. # Select "Iterate Until Done" to access all records in the datapool. # Select "Use Current Record" to use the same record across the call script. Step - 6: Click "Insert Code". RFT inserts the callScript ("scriptname") code at the cursor location, where scriptname is the name we had selected in the "Script Name" field. Step - 7: Click "Close" to remove the Script Support Functions dialog box from the screen. Important: we can also insert one or more callScript commands by: a) For RFT - Java Scripting - from the "Functional Tester Projects view". b) For RFT - VB.NET Scripting - from the "Solution Explorer".

Tutorial - 14 : How to insert a verification point from the script explorer using IBM Rational Functional Tester - RFT
This article presents a simple method of inserting a verification point from the script explorer using IBM RFT The most common way to create a verification point is while recording. But we can also insert a verification point any time from the Script Explorer (in RFT - Java Scripting, the right-most pane and in RFT - VB.NET Scripting, the leftmost pane) in the RFT window when we are not recording. Steps to insert a verification point while we are not recording are as under: Step - 1: Start the test application if it is not open. Step - 2: Open the script we want to insert the verification point into so that it is displayed in the script window. Step - 3: Put the cursor at the place in the script that we want to insert the verification point. Step - 4: Right-click "Verification Points" in the Script Explorer, and click "Insert Verification Point". This will open the Verification Point and Action Wizard. Step - 5: On the "Select an Object" page, use one of the selection methods to pick the object in the application, and click "Next". Step - 6: On the "Select an Action" page, select one of the verification point types. Click "Next". Step - 7: Edit the verification point properties or data. Step - 8: Click "Finish".

The verification point will be added to our script in the location of the cursor, and will be added to the Script Explorer in the Verification Points list. Important: If we click "Finish" and have no properties or data selected for testing (checked), a warning will display and the script is not modified.

Tutorial - 15 : How to replace an exact match property with a Pattern using IBM Rational Functional Tester - RFT
You can replace a recognition property with a regular expression or a numeric range to allow for a pattern-based recognition. The pattern allows for more flexibility in the object recognition. You can convert properties to regular expressions or numeric ranges from within both the Verification Point Editor and the object map. You can undo any regular expression or numeric range. After you convert a value to a regular expression or numeric range, the shortcut menu then contains an Undo command, which you can use to return to the original value. Steps to use a regular expression from the test object map are as under: Step - 1: Select the object in the test object map or in the Unification wizard. Step - 2: In the Recognition Property grid in the map or in the top pane of the Unification wizard, right-click the value to change and select "Convert Value to Regular Expression". The value is designated as a regular expression by the blue in front of the value text. Step - 3: Click another property in the grid, and then double-click the value so that we can edit the field. # Alternatively, we can edit the expression in the "Regular Expression Evaluator". # To test our regular expression while we edit it, we can use the "Regular Expression Evaluator". In "Step 3", right-click the expression, and click "Evaluate Regular Expression". # The "Pattern" and "Match Against Value" fields contain the current value. # To try an expression, change the value in the "Pattern" field and click the "Evaluate" button. # The "Result" indicates whether the expression matched. Step - 4: Edit the value. For example, if it is a text property of "customer" we can change it as described here. # [cC]ustomer : This syntax allows any text that contains the word "customer" with either an uppercase "C" or lowercase "c" will match. This is important because the comparisons are casesensitive. # We can change a case-insensitive comparison by using the Regular Expression Evaluator, or in the interface of the object map, Verification Point Editor, and Verification Point Comparator. # In the Regular Expression Evaluator, we can set an option for case sensitivity. The "Perform Case Sensitive Match" option is on by default. Matching is case-sensitive.

# If we want matching to ignore case, we need to clear this option. We can set case sensitivity in the interface of the object map or the Verification Point Editor and Comparator. # In these tools, when we right-click on a regular expression value, we can click "Case Sensitive Regular Expression". Step - 5: Click outside that cell again. We are finished if we were in the test object map. If we used the Unification Wizard in the map, click "Next", and click "Finish". Step - 6: Click "Save" in the object map.

Tutorial - 16 : How to pass parameters from one script to another by CallScript Method using IBM Rational Functional Tester - RFT
The example uses two different Functional Tester scripts: a) Script - 1: TheCaller, which calls another script and passes parameters b) Script - 2: TheCalled, which receives the parameters and prints them to System.out TheCaller script further uses three different versions of the callScript method: Version - 1: Without additional parameters: This is the default usage of the callScript method, which will execute the specified script. callScript("TheCalled"); Version - 2: With additional string array parameter: An array of strings is used to pass string parameters to the called script. String[] dataToPass = new String[4]; ... callScript("TheCalled",dataToPass); Version - 3: With additional object array parameter: An array of objects is used to pass different object type parameters to the called script. Object[] objdataToPass = new Object[4]; ... callScript("TheCalled",objdataToPass); The TheCaller script sample had been recorded as under: import import import import import import import import resources TheCallerHelper; com.rational.test.ft.*; com.rational.test.ft.object.interfaces.*; com.rational.test.ft.object.interfaces.SAP.*; com.rational.test.ft.object.interfaces.siebel.*; com.rational.test.ft.script.*; com.rational.test.ft.value.*; com.rational.test.ft.vp.*;

/** * Description : Functional Test Script * @author Administrator */ public class TheCaller extends TheCallerHelper { /** * Script Name : TheCaller * Generated : Feb 10, 2008 7:24:08 PM * Description : Functional Test Script * Original Host : WinNT Version 5.1 Build 2600 (S) * * @since 2008/02/10 * @author Administrator */ public void testMain (Object[] args) { callScript("TheCalled"); String[] dataToPass = new String[4]; dataToPass[0] = "this"; dataToPass[1] = "is"; dataToPass[2] = "really"; dataToPass[3] = "cool"; callScript("TheCalled",dataToPass); Object[] objdataToPass = new Object[4]; objdataToPass[0] = new String("Thought the previous was cool?"); objdataToPass[1] = "Take this one!"; objdataToPass[2] = new Float(0.02); objdataToPass[3] = new Integer(4711); callScript("TheCalled",objdataToPass); } } The TheCalled script uses a simple loop to print the received parameters to System.out: import resources.TheCalledHelper; 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 Tester Script * @author Administrator */ public class TheCalled extends TheCalledHelper { /** * Script Name : TheCalled * Generated : Feb 10, 2008 7:24:08 PM * Description : Functional Test Script * Original Host : WinNT Version 5.1 Build 2600 (S) * * @since 2008/02/10 * @author Administrator */

public void testMain (Object[] args) { if (args.length < 1) { System.out.println( "Expected at least 1 arg, however we got: "+args.length); return; } else { System.out.println( "Got: "+args.length+" args"); } for (int i = 0; i < args.length; ++i) { System.out.println( " arg["+i+"] = "+args[i]); } } }