Winrunner Vs QTP (下集)

WinRunner
Summary:

This product is a mature 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 scrīpt to simulate the same actions just performed.  The scrīpt is displayed as a program which can be enhanced with checkpoints, logic and special coding/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 is the descrīption from the Mercury “Features and Benefits” section of the WinRunner web page:
Significantly increase power and flexibility of tests without any programming: The Function Generator presents a quick and error-free way to design tests and enhance scrīpts 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: WinRunner's 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 scrīpt and can be tested.
Maintain tests and build reusable scrīpts: 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 scrīpts, eliminating the need to build new scrīpts 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 scrīpts: WinRunner's DataDriver Wizard greatly simplifies the process of preparing test data and scrīpts. 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 scrīpts 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. WinRunner's 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 scrīpts with QuickTest Professional.

- WinRunner “Features and Benefits” webpage from Mercury:
http://www.mercury.com/us/products/quality-center/functional-testing/winrunner/features.html
Pros:
· Mature product that has been around since about 1995.
· Simple interface.
· Many features.
· Many consultants and user group/forums for support.
· Decent built in help.
· Fewer features to have to learn and understand compared to QuickTest Pro.
· Interfaces with the Windows API.
· Integrates with TestDirector.

Cons:
· Has basically been superceded by QuickTest Pro.
· Looking at “program code” for the test case.
· Coding is done in a proprietary language (TSL).
· Very few resources available on TSL programming (it is based on the C programming language, but is not C).
· Need to be able to program to a certain extent in order to gain flexibility and parameterization.
· Need training to implement properly.
· The GUI Map can be difficult to understand and implement.

 
QuickTest Pro

Summary:
QuickTest Professional provides an interactive, visual environment for test development. 

Here is the descrīption from the Mercury Interactive “How it Works” section of the QuickTest Pro web page:
Mercury QuickTest Professional™ allows even novice testers to be productive in minutes. You can create a test scrīpt by simply pressing a Record button and using an application to perform a typical business process. Each step in the business process is automated documented with a plain-English sentence and screen shot. Users can easily modify, remove, or rearrange test steps in the Keyword View.

QuickTest Professional can automatically introduce checkpoints to verify application properties and functionality, for example to validate output or check link validity. For each step in the Keyword View, there is an ActiveScreen showing exactly how the application under test looked at that step. You can also add several types of checkpoints for any object to verify that components behave as expected, simply by clicking on that object in the ActiveScreen.

You can then enter test data into the Data Table, an integrated spreadsheet with the full functionality of Excel, to manipulate data sets and create multiple test iterations, without programming, to expand test case coverage. Data can be typed in or imported from databases, spreadsheets, or text files.

Advanced testers can view and edit their test scrīpts in the Expert View, which reveals the underlying industry-standard VBscrīpt that QuickTest Professional automatically generates. Any changes made in the Expert View are automatically synchronized with the Keyword View.

Once a tester has run a scrīpt, a TestFusion report displays all aspects of the test run: a high-level results overview, an expandable Tree View of the test scrīpt specifying exactly where application failures occurred, the test data used, application screen shots for every step that highlight any discrepancies, and detailed explanations of each checkpoint pass and failure. By combining TestFusion reports with Mercury Quality Management, you can share reports across an entire QA and development team.

QuickTest Professional also facilitates the update process. As an application under test changes, such as when a “Login” button is renamed “Sign In,” you can make one update to the Shared Object Repository, and the update will propagate to all scrīpts that reference this object. You can publish test scrīpts to Mercury Quality Management, enabling other QA team members to reuse your test scrīpts, eliminating duplicative work.

QuickTest Professional supports functional testing of all popular environments, including Windows, Web, .Net, Visual Basic, ActiveX, Java, SAP, Siebel, Oracle, PeopleSoft, terminal emulators, and Web services.

- QuickTest Pro “How it Works” webpage from Mercury:
http://www.mercury.com/us/products/quality-center/functional-testing/quicktest-professional/works.html

We like QuickTest Pro and now prefer implementing it over WinRunner.  When you get into advance testing scenarios, QuickTest Pro has more options and they are easier to implement compared to WinRunner in our opinion.

Do to the similarities in concept and features, an experienced WinRunner user can easily convert to QuickTest Pro and quickly become an efficient Test Automation Engineer!

We recommend that existing customers begin all new development with QuickTest Pro and use the built-in feature of calling WinRunner scrīpts from QuickTest Pro for all existing WinRunner scrīpts that they already have.  As older scrīpts require updates and time permits, we recommend replacing them with QuickTest Pro scrīpts.  Eventually you will be able to convert your test scrīpt library with all QuickTest Pro scrīpts.
Pros:
· Will be getting the initial focus on development of all new features and supported technologies.
· Ease of use.
· Simple interface.
· Presents the test case as a business workflow to the tester (simpler to understand).
· Numerous features.
· Uses a real programming language (Microsoft’s VBscrīpt) with numerous resources available.
· QuickTest Pro is significantly easier for a non-technical person to adapt to and create working test cases, compared to WinRunner.
· Data table integration better and easier to use than WinRunner.
· Test Run Iterations/Data driving a test is easier and better implement with QuickTest.
· Parameterization easier than WinRunner.
· Can enhance existing QuickTest scrīpts without the “Application Under Test” being available; by using the ActiveScreen.
· Can create and implement the Microsoft Object Model (Outlook objects, ADO objects, FileSystem objects, supports DOM, WSH, etc.).
· Better object identification mechanism.
· Numerous existing functions available for implementation – both from within QuickTest Pro and VBscrīpt.
· QTP supports .NET development environment (currently WinRunner 7.5 does not).
· XML support (currently WinRunner 7.5 does not).
· The Test Report is more robust in QuickTest compared to WinRunner.
· Integrates with TestDirector and WinRunner (can kick off WinRunner scrīpts from QuickTest).
Cons:
· Currently there are fewer resources (consultants and expertise) available due to QTP being a newer product on the market and because there is a greater Demand than Supply, thus fewer employee/consulting resources.
· Must know VBscrīpt in order to program at all.
· Must be able to program in VBscrīpt in order to implement the real advance testing tasks and to handle very dynamic situations.
· Need training to implement properly.
· The Object Repository (OR) and “testing environment” (paths, folders, function libraries, OR) can be difficult to understand and implement initially.