Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
2. Rational Administrator
It is a tool for managing associations between Rational artifacts such as Test Datastores,
Requisite Pro projects and Rose models.
3. Recording Options
Using Object oriented technology, Robot identifies an object by its name property not by
its location coordinates. There are two different options
4. SQABasic language
SQABasic is similar to Microsoft Visual Basic. All the scripts will be in scriptname.rec
format. When you playback the script, Robot automatically compiles and runs the
script, which repeats your actions and executes the verification points.
5 Shell Scripts
It is a master script that calls other automated scripts and plays them back in sequence.
“callscript test1” is a command to call script named test1. Combined into a single shell
script, scripts can run in unattended mode and perform comprehensive test coverage. It
centralizes test results into one test log.
7 Verification Points
Verification points verify that a certain action has taken place, or verify the state of an
object. There are 11 Verification points in Robot
When you are creating verification points, there will be two options – Wait State and
expected Results.
Wait states are useful when AUT requires an unknown amount of time to complete a
task. Using a wait state keeps the verification point form failing if the task is not
completed immediately or if the data is not accessible immediately.
Expected Results – Click Pass or Fail in the Verification Point Name dialog box.
8 Variable Window
During debugging, if you want to examine variable and constant values, you can
variables window. View->Variables.
9. Object Mapping
If AUT contains a custom object or any object that Robot does not recognize, you
can create a custom object mapping before start recording. By adding the object’s
class to the list of classes that Robot recognizes, and then associating the class to a
standard object type. Robot saves this custom class/object type mapping in the
project and uses it to identify the custom object during playback.
10 Debug Tools
Animate(F11) – Animation mode allows you to see each line of script as it executes.
Step Over(F10) – Use to execute a single command line within a script
Step Into(F8) – Use to being single step execution
Step Out(F7) – Use to step out of the called script and return to the calling script.
Go Until Cursor(F6) – Use to play back the active GUI script, stopping at the text
cursor location.
13 Data Pool
A Datapool is a test dataset that supplies data variables in a test script during playback.
Using datapools allows you to run multiple iterations of a script using different data each
time. It can be created and managed using Test Manager for data driven tests.
2. Rational Robot provides test cases for common objects such as menus, lists,
bitmaps and specialized test cases for objects specific to the development
environment.
3. It integrates with tools like Rational Test Manager, Rational Clearquest and
Requisite Pro in the Rational Unified Processor for Defect Tracking, Change
Management and Requirement Traceability. It supports windows platform.
4. It reduces the time and man power spent on functional testing. It covers both
visible and invisible objects. It also supports multiple UI technologies.
Rational Administrator:
2. Connect, Delete, and Register (to see projects that are not in the machine) a
project.
3. Create and manage users and groups for rational test datastore.
4. Create and manage projects that contain rational requisitepro projects and
rational rose models.
Project:
3. Projects are used to organize testing information’s and resources for easy
tracking.
4. Each project has a database and several directory files.
5. Each rational component updates and retrieves the data from the active
project.
Recording Options:
Shell Scripts:
It is a master script that calls other automated scripts and plays them back in
sequence. “callscript test1” is a command to call script named test1. Combined into
a single shell script, scripts can run in unattended mode and perform
comprehensive test coverage. It centralizes test results into one test log.
Turn “Low Level Recording On” in Robot during recording, mouse and
keyboard actions are automatically stored in an external file.
Verification Points:
Verification points verify that a certain action has taken place, or verify the
state of an object. It is also defined as the location in the instruction where the actual
result is compared with the expected result. There are 11 Verification points in
Robot
2. Object Properties: Tests object attributes such as color, font and position.
3. Menu: Verifies the menu values and optionally their state (enabled or
disabled) of a window.
5. Window Existence: Tests to see if a particular window does or does not exist
on the screen.
6. Region Image: Graphically compares an area of the screen you specify.
9. File Comparison: Compares the contents of the two files (size and the
contents).
11. Module Existence: Used to verify whether a specified module is loaded into a
specified context, or loaded anywhere in memory.
When you are creating verification points, there will be two options – Wait State
and expected Results.
Wait states: Are useful when AUT requires an unknown amount of time to
complete a task. Using a wait state keeps the verification point from failing if the
task is not completed immediately or if the data is not accessible immediately.
Expected Results: Click Pass or Fail in the Verification Point Name dialog box.
Variable Window:
During debugging, if you want to examine variable and constant values, you
can Variable Window. View->Variables.
Object Mapping:
If AUT contains a custom object or any object that Robot does not recognize,
you can create a custom object mapping before start recording. By adding the
object’s class to the list of classes that Robot recognizes, and then associating the
class to a standard objects type. Robot saves this custom class/object type mapping
in the project and uses it to identify the custom object during playback.
Debug Tools:
1. Animate (F11) – Animation mode allows you to see each line of script as it
executes.
2. Step Over (F10) – Use to execute a single command line within a script.
4. Step Out (F7) – Use to step out of the called script and return to the calling
script.
5. Go Until Cursor (F6) – Use to play back the active GUI script, stopping at
the text cursor location.
Header files have .sbh extensions and contain the procedure declarations and
global variables referred to in your script files. There are two types of library files.
Those with .sbl extensions can’t have verification points. Those with .rec extensions
are stored in the project and can have verification points. Both Header and library
are in \SQABAS32 in the project directory.
Image masks are used to hide an area of the screen. When you play back a
script that contains an Image VP and a mask, Robot ignores the masked area when
comparing actual results to the recorded baseline.
Data Pool:
A Datapool is a test dataset that supplies data variables in a test script during
playback. Using datapools allows you to run multiple iterations of a script using
different data each time. It can be created and managed using Test Manager for
data driven tests.
Data pools pump different kind of test data into script each time a script
sends data to the server. During playback, script sends transactions.
1. Data pool values are stored in text file with (.CSV extension)
.CSV and .SPC files are stored in data pool directory of your process.
Rational Test Manager:
To plan tests, manage test assets and to run queries and reports. It is used to
1. TestManager is the open and extensible framework that unites all of the
tools, assets, and data both related to and produced by the testing effort.
2. Under this single framework, all participants in the testing effort can define
and refine the quality goals they are working toward.
3. It is where the team defines the plan it will implement to meet those goals.
And, most importantly, it provides the entire team with one place to go to
determine the state of the system at any time.
4. Testers use TestManager to see what work needs to be done by whom and by
what date. Testers can also see what areas of their work are affected by
changes happening elsewhere in the development effort.
• Planning tests
• Designing tests
• Implementing tests
• Executing tests
• Evaluating tests
Plan Test:
Design Test:
Implement Test:
Execute Tests:
The activity of executing your tests is primarily running your scripts to make
sure that the system functions correctly. In TestManager, you can run any of the
following: (1) an individual script, which runs a single implementation; (2) one or
more test cases, which run the implementations of the test cases; (3) a suite, which
runs test cases and their implementations across multiple computers and users.
Evaluate Tests:
1. Rational Clear Quest is a powerful and highly flexible defect and change
tracking system that captures and manages all types of change requests
throughout the development lifecycle, helping organizations quickly deliver
higher quality software.
2. Clear Quest scales to support projects of any size and integration with other
development solutions ensures that your entire team is tied into the defect
and change tracking process.
4. Clear quest web: Used by everyone, to access clear quest across multiple
platforms through Netscape navigator, I.E., you can submit change requests
and run queries, charts and reports.
2. It automatically evaluates what percentage of code has and has not been
exercised.
Rational Purify:
2. It can check not only users’ source codes, but also libraries and even
components, No matter whether there are source codes for them. Code
coverage data that pinpoints untested code.
3. It permits programmers to control the error checking level for each code
module. It can quickly analyze executables, without any rebuilding.
Rational Quantify:
• It is used to identify bottlenecks and then reduce or eliminate them that are
used for performance tuning and engineering.
We put all our requirements in RequisitePRO and create test cases in test
manager and maintain traceability between them.
Rational Rose:
Rational rose is used to model, generate and reverse engineer code for
applications written in VB, Java etc. We can create Use-Case models, state
transition models etc.
Rational Soda:
It automates the creation of software documentation, it extracts information
from software engineering tools such as rational rose and requisite pro using
templates in word, it formats the info and extracts into a report, it preserves the text
and we can use it to create document.
Refer: http://www.seqcm.com.tw/Product/IBM/SoDA.pdf
Refer: http://www.wilsonmar.com/1robosqa.htm
Within Robot, when you pull down menu File > New, you see the different
types of files testers might create:
• Reusable code is organized into functions that are called from a script library
header file. The name of such header files is included in scripts that use those
functions.
• It structurally ensures that both function libraries and scripts that use them
declare those functions and global constants the same way.
• Header files declare constants, variables, custom sub procedures, and custom
functions which are common across an organization's scripts.
• This allows for code reuse in many scripts, thereby also standardizing
programming practices.
GUI Shell Scripts:
3. Then we create a Test Plan in Test Manager (Test Plan Name, Description,
In external Documents Tab attach Test Plan word document).
4. Then we create Test Case folders (like Integration Test Cases, System Test
Cases, and Performance Test Cases).
5. In Test Case folders, we insert test cases (Test Case Name, Test Case
description, Design steps, Pre-Condition, Post-Condition, Acceptance-
Criteria, Attach requirement from RequisitePRO or Rose Model from Rose
as Test Input for traceability).
6. For Manual test scripts, we can import the design and create a Manual test
scripts or we Automate the Robot script from design of test case by inserting
the necessary verification point.
7. We can also create a Test Suite or Shell script by putting a Call command
and run the all test scripts together.
8. We run or playback the scripts and view the results in Test Log Viewer and
can analyze the results in comparators.
Artifacts:
Are either final or intermediate work products produced and used during a project.
Artifacts capture and convey project information, and may take various shapes or
forms
Object-oriented technology:
A general term which describes tools, processes, and programming languages
concerned with the development of systems that consist of chunks of data known as
objects.
Data-driven testing:
Is a term used in the testing of computer software for the creation of re-usable test
logic to reduce maintenance and improve test coverage. It is a methodology used in
test automation where test scripts are executed and verified based on the data values
stored in one or more central data sources or databases.
• A Rational Project.
Click : Start > Programs > Rational Software > Rational Robot
When you record a GUI script, Robot records your actions as you use the
application-under-test.
These user actions include keystrokes and mouse clicks that help you
navigate through the application.
Any windows that are open, active or displayed when you begin recording
should be open, active, or displayed when you stop recording. This applies to all
applications, including Windows Explorer, e-mail, and so on.
Robot can record the sizes and positions of all open windows when you start
recording, based on recording options. During playback, Robot attempts to restore
windows to their recorded states and inserts a warning into the log if it cannot find a
recorded window.
In general, close any unnecessary applications before you start to record.
Creating Modular Scripts:
Rather than defining a long sequence of actions in one GUI script, you
should define scripts that are short and modular. Keep your scripts focused on a
specific area of testing -- for example, on one dialog box or on a related set of
recurring actions.
When you need more comprehensive testing, modular scripts can easily be
called from or copied into other scripts. They can also be grouped into shell scripts,
which are top-level, ordered groups of scripts.
1. Click the Record GUI Script button on the toolbar to open the Record
GUI dialog box.
2. Type a name or select a script from the list.
• The floating GUI Record toolbar appears. You can use this toolbar to pause
or stop recording, display Robot, and insert features into a script.
8. When finished click the Stop Recording button on the GUI Record
toolbar.
The script you recorded appears in a Script window within the Robot main
window.
• Start recording
• End recording
After you record a script, play it back to verify that it works as intended.
Use the same build of the application-under-test that you used to record the script.
After you play back the script, Robot writes the results to a log. Use Rational Test
Manager to view the log. The results should validate the baseline of expected
behavior for the application-under-test.
After you play back a script, you may decide to edit the script to make it
more usable For example, you may want to insert manual code into the script. You
may also want to print your script or compile changes.
You may need to debug your script to locate errors. Robot includes a
complete, built-in debugging environment to assist you in the development phase of
your GUI script.
The Playback button is used to playback a recorded script. Alternately, File >
Playback… can be used...
Rational robot tutorial link:
http://sqa.fyicenter.com/Rational_Robot_Tutorial/
1. Use Robot to develop two kinds of scripts: GUI scripts for functional testing
and
sessions for performance testing.
2. Perform full functional testing. Record and play back scripts that navigate
through your application and test the state of objects through verification
points.
4. Create and edit scripts using the SQABasic and VU scripting environments.
The Robot editor provides color-coded commands with keyword Help for
powerful integrated programming during script development. (VU scripting
is
used with sessions in performance testing.)
5. Test applications developed with IDEs such as Java, HTML, Visual Basic,
Oracle Forms, Delphi, and PowerBuilder. You can test objects even if they
are
not visible in the application's interface.
Use TestManager to view the logs that are created when you run scripts and
schedules.
• Text Comparator
• Grid Comparator
• Image Comparator
Script Properties:
4. Custom keywords.
• Starting an application
• Inserting a call to another script
• Inserting timers
• Inserting comments
You can use timers to measure general application performance and specific task
performance.
For specific task performance, you often use timers with verification points
that have wait state values. You use the wait state value to detect the completion of a
task before stopping the timer.
The following is an example of using timers for specific task performance testing:
• Robot lets you insert start timer and stop timer commands to record and
write to the log the duration of events in a script. A timer measures the time
it takes to perform an activity.
• For example, you may want to record the time required to perform a
database transaction on a remote server, or how long it takes the same
verification point to execute on client machines with different hardware
configurations.
• You can insert any number of timers with different names into the same
script to measure a variety of separate tasks.
• You can nest timers within other timers (starting and stopping the second
timer before stopping the first timer). You can overlap timers (stopping the
second timer after stopping the first timer). However, you should stop a
timer before starting that same timer over again.
• If you start the same timer twice without stopping it, Robot terminates the
first occurrence when it starts the second. The timer is stopped automatically
at the end of the transaction.
Do the following before you play back a script that includes timers:
3. In the Playback tab, set the Delay between commands value to 0. This
removes any extra Robot timing delays from the performance measurement.
If you need a delay before a single command, click Insert > Delay and type a
delay value.
4. Click OK.
You want to verify that the Cut command places selected data on the
Clipboard.
The objects that you should test are the Cut command on the Edit menu and
the data on the Clipboard.
You create verification points to test that 1) the Cut command exists on the
Edit menu and is enabled, and 2) the Clipboard contains the information cut
to it.
If recording, click the Display GUI Insert Toolbar button on the GUI Record
toolbar.
If editing, position the pointer in the script and click the Display GUI Insert
Toolbar button on the Standard toolbar.
3. In the Verification Point Name dialog box, edit the name of the verification
point as appropriate.
Robot automatically names the verification point with the verification point
type, and adds a number if there is more than one of the same type in the
script.
4. Optionally, set the Wait state options. The wait state specifies how often
Robot should retry the verification point until it passes or times out, and how
long Robot should keep trying the verification point before it times out.
5. Optionally, set the Expected result option. When you create a verification
point, the expected result is usually that the verification point will pass -- for
example that a window does exist during playback. However, you can also
indicate that you expect the verification point to fail -- for example that a
window does not exist during playback.
6. Click OK.
Using a wait value keeps the verification point from failing if the task is not
completed immediately or if the data is not accessible right away.
For example, suppose you create an alphanumeric verification point that tests for a
specific string in a text box. When you play back the script, Robot first looks for the
text box. The verification point fails immediately if the box does not exist. If Robot
finds the box, it checks for the string in the box. However, the string might not be
in the box yet (your application might be running slowly and the box might not be
updated yet). To solve this, include wait values so that Robot retries the test (checks
for the string) every two seconds. If the content of the box does not match the string
within 30 seconds, the verification point returns a failure indication to the script.
For verification points that verify the properties or data of an object, Robot must
first find the specified object before it can perform the verification point. After it
finds the object, the following happens:
• If a wait state is specified, then Robot does the following, as shown in this
pseudo-code example:
2. In the Verification Point Name dialog box, select Apply wait state to
verification point.
Retry every How often Robot retries the verification point during playback.
Robot retries until the verification point passes or until the timeout limit is
reached.
Timeout after the maximum amount of time that Robot waits for the
verification point to pass before it times out. If the timeout limit is reached
and the verification point has not passed, Robot enters a failure in the log.
The script playback either continues or stops based on the setting in the
Error Recovery tab of the GUI Playback Options dialog box.
Selecting and Identifying the Object to Test:
When you create certain verification points, you need to select the object to
test. You do this by pointing to the object with the Object Finder tool, or by
selecting the object from a list of all objects on the Windows desktop. When
you point to an object, you can use one of several methods to visually identify
the object before you actually select it.
• Select it from a list of all objects on the desktop. This is useful for selecting
hidden objects.
Stores test assets such as scripts, Functional Test logs, object maps,
verification point baseline files, and script templates.
Stores test assets such as test plans, test cases, test logs, reports, and builds.
Stores visual models for business processes, software components, classes and
objects, and distribution and deployment processes.
2. Right click on “PROJECT” and choose the option “NEW PROJECT” from
the pop up menu.
5. Click on “NEXT”
6. If you want a password for your project, you can have a project. This
prevents others from deleting or editing your project.
7. Click on “NEXT”
8. Click on “FINISH”
For projects involving more than one person, Rational recommends using
Sybase SQL Anywhere.
2. Click on File New Script, type a name and description for the new script.
5. In the GUI Record toolbar click on the option display GUI Insert toolbar.
7. Choose start application or start java application or start browser for to start
the program to be recorded for testing.
8. After recording in the GUI Record toolbar, click on the Stop Recording icon.
11. To play the scripts again click on Playback Script Button or File Playback.
Creating The Test Plan - Specifying Inputs to Test Inputs:
Description, Status and Last Modified and set the formatting on the last
column to a format supporting Data and Time. Fill up the table as shown in
• You must log into a Rational Administrator Project to continue. Select the
Admin user with a blank password. For this tutorial this will suffice,
however on actual projects you will want to create a username and password
for each member of the team. Just click OK to use the Admin username.
• Expand the Test Plans folder and right click Test Plan 1 and rename it to
Classics Online
• Double click on the Test Plan to open
• Right click on the Test Plan name and click Insert Test Case folder
• Name the folder Verify Customer Name, enter a description and click okay
Repeat the previous steps to create the following Test Plan Structure
Connecting to the Excel Spreadsheet:
• In the New Input Source window, type the name Application Requirements
• Click the Connection Data tab and in the Data Path field, click browse, and
• Click the Set Configuration button and click yes on the Save dialog box that
pops up
• Fill the dialog window with the values shown below and press okay
Viewing the Test Inputs