Experiment no :

Aim: Study of any testing tool win runner tool

Winrunner product is a big automation testing tool that has been around since approximately 1995. It
interfaces with most of the leading development toolkits using the WindowsAPI and toolkit DLLs to
interface with the Application Under Test. WinRunner offers a recording feature that will watch the
individual tester and generate a test script to simulate the same actions just performed. The script is
displayed as a program which can be enhanced with checkpoints, logic and special coding or
programming.
WinRunner also has integration with Excel spreadsheets for data driven testing and the ability to write
data out in Excel format or in simple text files. Here are some description from the Mercury Features
and Benefits of WinRunner :

Considerably increase power and flexibility of tests without any programming: The
Function Generator presents a quick and error-free way to design tests and enhance scripts without
any programming knowledge. Testers can simply point at a GUI object, and WinRunner will examine it,
determine its class and suggest an appropriate function to be used.

Use multiple verification types to ensure sound functionality: WinRunner provides

checkpoints for text, GUI, bitmaps, URL links and the database, allowing testers to compare expected
and actual outcomes and identify potential problems with numerous GUI objects and their
functionality.

Verify data integrity in your back-end database: Built-in Database Verification confirms
values stored in the database and ensures transaction accuracy and the data integrity of records that
have been updated, deleted and added.

View, store and verify at a glance every attribute of tested objects: WinRunners GUI
Spy automatically identifies, records and displays the properties of standard GUI objects, ActiveX
controls, as well as Java objects and methods. This ensures that every object in the user interface is
recognized by the script and can be tested.

Maintain tests and build reusable scripts: The GUI map provides a centralized object
repository, allowing testers to verify and modify any tested object. These changes are then
automatically propagated to all appropriate scripts, eliminating the need to build new scripts each time
the application is modified.

Test multiple environments with a single application: WinRunner supports more than 30
environments, including Web, Java, Visual Basic, etc. In addition, it provides targeted solutions for
such leading ERP/CRM applications as SAP, Siebel, PeopleSoft and a number of others.

Simplify creation of test scripts: WinRunners DataDriver Wizard greatly simplifies the
process of preparing test data and scripts. This allows for optimal use of QA resources and results in
more thorough testing.

Automatically

identify discrepancies

in data: WinRunner

examines

and

compares

expected and actual results using multiple verifications for text, GUI, bitmaps, URLs, and databases.
This ensures stable functionality and execution of business transactions when the application is
released into production.

Validate applications across browsers: WinRunner enables the same test to be used to
validate applications in Internet Explorer, Netscape, and AOL. This saves testing time and reduces the
number of scripts that must be developed and maintained.

Automatically recover tested applications from a crash: Unexpected events, errors, and
application crashes during a test run can disrupt the testing process and distort results. WinRunners
Recovery Manager enables unattended recovery and provides a wizard that guides the process of
defining a recovery scenario.

Leverage investments in other testing products: WinRunner fully integrates with our
other testing solutions, including LoadRunner for load testing and TestDirector for global test
management. Moreover, organizations can reuse WinRunner test scripts with QuickTest Professional.
P WinRunner software was an automated functional GUI testing tool that allowed a user to record and
play back UI interactions as test scripts. As a functional test suite, it worked with HP Quick Test
Professional and supported enterprise quality assurance. It captured, verified and replayed user
interactions automatically, in order to identify defects and determine whether business processes
worked as designed. The software implemented a proprietary Test Script Language (TSL) that allowed
customization and parameterization of user input. HP WinRunner was originally written by Mercury
Interactive. Mercury Interactive was subsequently acquired by Hewlett Packard (HP) in 2006.
Important features of WinRunner are :

Functional / Regression testing of a variety of application software written in programming

languages such as PowerBuilder, Visual Basic, C/C++, and Java can be done.

Testing of ERP / CRM software packages can also be carried using WinRunner.

Testing in all flavors of Windows operating systems and different browser environments such
as Internet Explorer and Netscape Navigator can be done.

GUI operations can be recorded in the record mode. WinRunner automatically creates a test
script. This test can be modified if required and can be executed later on in unattended mode.

Checkpoints can be added to compare actual and expected results. The checkpoints can be
GUI checkpoints, bitmap checkpoints and web links.

Facility for synchronization of test cases is provided.

Data Driver Wizard provides the facility to convert a recorded test into a data driven test.

Database checkpoints are used to verify data in a database during automated testing.

The Virtual Object Wizard of WinRunner is used to teach WinRunner to recognize, record, and
replay custom objects.

The reporting tools provide the facility to generate automatically the test reports and analyze
the defects.

We use Win Runner as a load testing tool operating at the GUI layer as it allows us to record
and playback user actions from a vast variety of user applications as if a real user had manually
executed those actions. We use Win Runner in addition to Load Runner when we want to record user
experience response time.
There are two type of recording modes in WinRunner :

1.

Context Sensitive recording records the operations you perform on your application by
identifying Graphical User Interface (GUI) objects. Winrunner identifies all the objects in your window
you click like menus, windows, lists, buttons and the type of operation you perform such as enable,
move, select etc.

2.

Analog recording records keyboard input, mouse clicks, and the precise x- and y-coordinates
traveled by the mouse pointer across the screen i.e Winrunner records exact co-ordinates traveled by
mouse.

WinRunner is a program that is responsible for the automated testing of software. It is

designed to function with Windows applications, and it was designed by Mercury
Interactive Corporation, an organization that is based in California. WinRunner will allow
you to make comparisons between various outcomes.
A series of wizards will be provided to the user, and these wizards can create tests in an
automated manner. Another impressive aspect of Winrunner is the ability to record
various interactions, and transform them into scripts. WinRunner is designed for testing
GUIs, or Graphic User Interfaces.
When the user make an interaction with the GUI, this interaction can be recorded.
Recording the interactions will allow you to determine various bugs that need to be
fixed. The goal of WinRunner is to make sure business processes are properly carried
out. WinRunner uses TSL, or Test Script Language. The input of the user can be
customized at various levels. WinRunner will test the computer program in a way that is

very similar to normal user interactions. This is important, because it ensures a high
level of accuracy and realism. Even if an engineer is not physically present, the Recover
manager will troubleshoot any problems that may occur, and this will allow the tests to
be completed without errors.
When the test is completed, WinRunner will provide you with detailed information
regarding the results. It will show you the errors that were found, and it will also give
you important information about them. The good news about these tests is that they
can be reused many times. For example, if you decide that you want to make
modifications to the program, it is not necessary for them to make changes to the
actual test. All they would need to do is make changes to the Graphic User Interface
Map. The GUI Map is a central collection of information that is related to software tests.
Once a change has been made to the GUI Map, it will be reflected in all the scripts that
are connected to it. There are a number of powerful advantages that WinRunner has
over similar applications. First, it reduces the complexity of setting up scripts for testing.
This allows you to test the software without a lot of effort, and you can accomplish it in
a short period of time. Another powerful advantage of WinRunner is that it makes a
comparison between results that are expected and the results that are manifested. It
uses things such as databases, URLs, and text. This allows the software product to have
a much higher stability, and the application will be more powerful when it is ready for
production.
The Recover Manager is a powerful tool that can assist users with various scenarios.
This is important, especially when important data needs to be recovered. WinRunner is
a tool that has consistently been reviewed in a positive manner. It is of great importance
in the software industry. Software development can be a tedious process, and it is very
important for users to make sure it is properly tested. In the past, this was exceptionally
difficult. Software had to be manually tested, and this often led to a number of errors
remaining undetected. With the advent of automated testing tools, things have become
much easier. Developers can now focus on the functions of the software, rather than
searching for bugs.
Errors in a program can be detrimental to its primary functions. The discovery and
removal of these errors is an important part of being a developer. Automated programs
such as WinRunner can make this task a whole lot easier. Many developers have stated
that removing bugs is the most challenging part of software development. WinRunner

makes the task easier by finding these errors. Once the errors are found, the developer
can focus on correcting or removing them. The testing of the GUI is crucially important.
The developer must make sure the testing reflects the type of interactions that will
occur in reality. This will allow them to handle errors in a much more efficient manner.
By generating testing scripts, WinRunner allows the developer to test the software with
a high level of realism. It will test the software in the same way that an actual user
would test this, and this would greatly reduce the number of errors that would be found.