Quick Test Professional blog

UFT 14.00 and its Features

2017-06-23T15:03:00.001-06:00

A while ago we've got introduced to UFT 14.00 directly from 12.54 (v.13 was actually skipped) which came in with multiple new features and updates. With that beign said please find more details below:

1. UFT License Changes / Updates

Bassically they introduced three new license versions eachone bringin in a different sub-set of functionality and these are:

UFT Ultimate - inlcudes UFT, UFT Pro (LeanFT), Sprinter, BPT, Mobile Center
UFT Enterprise - inlcudes UFT, UFT Pro (LeanFT), Sprinter
UFT Pro (LeanFT) - inlcudes UFT Pro (LeanFT)

You can find more details on HP-UFT and UFT-Licenses.
By the way, if you previously had a UFT license then it is now called UFT Enterprise while if you had a LeanFT licence in past the not it is called UFT Pro (LeanFT).

2. Integration of UFT with Microsoft TFS CI Systems

UFT can now work with Microsoft Team Foundation Server (TFS) CI using the UFT TFS Extension

3. Record and Run Settings were Redesigned

In order to make it easier to be used and enhance users experience the configurations forms were totally redesigned as below:

4. GUI tests Test Combinations Generator

This tool was basicaly created to help with:

generating sets of parameters values for the Global Data Table automatically
composite parameters generation (parameters build out of multiple parameter values)
excluding the parameters from the generated configuration

See more about Generating Test Configurations

5. UFT Help is available Online as Default

But you can still download a copy and switch the defaults to your local drive, see more on UFT 14.00 Download Help Center.

Videos are now also available through the Help portal.

6. Enhancements for Mobile Testing

With the new Mobile Center 2.20 UFT is now supporting the Sensor Simulation Operations on the Mobile Devices.
A Mobile Center Help iis available too.

7. MQTT protocol gets API Testing Support

If the service level of your application uses the MQTT protocol for communication then you can use the API tests.

8. The new Sniper mode

To quickly learn the objects in a given area of the application you ca now use the new Sniper mode - by using it you can capture all the objects in an area of the application simply by selecting the needed area of your application.

See more details here

9. Localization and UFT Tool Support changes

The installation of UFT is now available in multiple languages:

English
Chinese
Japanese
Russian
French
German

The UFT JRE Tool is no longer available after the installation

The Extensibility Accelerator was removed from the setup of UFT but it still can be downloaded from here.

10. Enhancements Technology-Specific

The ability to test various applications on different technologies was also improved:

Flex - double clicks usage with the DblClick method for all objects, ActivateCell method for FlexTable objects, working with FlexTable objects is now possible outside individual table cells.
UI Automation - the native object methods including descriptive programming usage for these objects and the UIAutomation Utility object got better support. See more details about Native UI Automation methods and the UIAutomation Utility object in the UFT Object Model Reference for GUI Testing.
Oracle - new OracleCalendar and OraclePickList objects for OracleForms 12c support were added.
Java - Java 8 is now installed in a budle together with UFT 14.00 and you don't need to add the -noverify attribute when working with apps on Java 8 anymore.

Additional New Technologies and Framework Support:

The latest versions of Firefox and Chrome.

Windows Server 2016

Autopass License Server 9.3

EXT-JS 6.0

SiebelOpenUI 16

Safari 10.12 ("Sierra")

SAPUI5 1.38

Visual Studio 2015 for the Testing Extensibility SDK

Solution Manager 7.2

Delphi Berlin 10.1

SAP Hybris

See more within the Unified Functional Testing Product Availability Matrix.

QTP Bibliography

2011-07-22T02:02:00.000-06:00

Bookmark It

Hide Sites

Check an alert dialog box and the text from it

2011-06-16T05:39:00.000-06:00

In this post I will try to describe step by step how to create a function which checks for a dialog box and will also click on the button within it:

Firstly we will create a class which we'll be calling on our need:

' creating the generic function
Public Function DialogBox
Set DialogBox = New QTPDialogBox
End Function

' defining the class
Class QTPDialogBox
Public Function CheckDialogBox (obj_DialogWindowId, obj_DialogWindowStyle, obj_StaticWindowId, obj_StaticText)
' defining the Dialog object's properties
Set obj_Dialog = Description.Create
obj_Dialog ("micclass").value = "Dialog"
obj_Dialog ("nativeclass").value = "#32770"
obj_Dialog ("text").value= "Microsoft Internet Explorer"
obj_Dialog ("window id").value= obj_DialogWindowId
obj_Dialog ("windowstyle").value= obj_DialogWindowStyle

' defining the Static object's properties
Set obj_Static = Description.Create
obj_Static ("micclass").value = "Static"
obj_Static ("window id").value= obj_StaticWindowId
obj_Static ("text").value= obj_StaticText
With Browser("URL:=" & Environment.Value("baseUrl"))
.Sync
'check if the dialog box exists
If .Dialog(obj_Dialog).Static(obj_Static).exist Then
' set a variable for the "text" property of Static object to be compared with the text value inserted by a user
DialogMessage = .Dialog(obj_Dialog).Static(obj_Static).GetRoproperty("text")
Dim Comparison
If Comparison = StrComp(Trim(obj_StaticText), Trim(DialogMessage), 0) Then
Reporter.ReportEvent micPass, "PASS", "The Dialog box is present on the screen, and the text from it is: '" & DialogMessage & "', it is the same as: '" & obj_StaticText & "'"
' click OK in dialog box
.Dialog(obj_Dialog).WinButton("text:=OK", "regexpwndclass:=Button", "window id:=2").Click
Else
Reporter.ReportEvent micFail, "Fail", "The Dialog box is present on the screen, and the text from it is: '" & DialogMessage & "', it is not the same as: '" & obj_StaticText "'"
End If
Else
Reporter.ReportEvent micFail, "FAIL", "There is no Dialog box present on the screen!"
End If
End with
End Function
End Class

[Notes]

Environment.Value("baseUrl") = it's your URL, which is defined into a XML config file, for e.g.: http://google.com/.*; see the XML variable below:

<Variable>
<Name>baseUrl</Name>
<Value>http://google.com/.*</Value>
<Description>This variable is used to identify the browser's URL</Description>
</Variable>

In this XML file, we can also have the user name, password, and a lot of general data which can be also called when it need.

To create the descriptions for Static and Dialog objects, use the Object Repository Manager.

Now we can call this Function within our test in the next way:
' check if the dialog box contains the correct text and click on OK button
DialogBox.CheckDialogBox "0", "-1798831675", "65535", "Functionality not implemented in this release"
' (obj_DialogWindowId, obj_DialogWindowStyle, obj_StaticWindowId, obj_StaticText) --- those are the properties added using Object Repository Manager

Bookmark It

Hide Sites

Set a DataBase connection and run any queries from QTP

2011-05-12T07:05:00.000-06:00

How to set a DB connection and to get a value from an "adodb" Data Base

Public Function DBSelect

set conn = createobject("adodb.connection")

conn.open "DSN=DSN_SERVERhere; UserID=userID; Password=password;"

set rs = createobject("adodb.recordset")

'get the date value from DB for an Event

rs.open "SELECT searchColumnHere FROM tableName WHERE columnName='value'", conn

eventsInDB = rs("searchColumnHere")

'eventsInDB = FormatNumber(eventsInDB, 2) - use this if you need to format the output nr

rs.close

DBSelect = eventsInDB 'here we are defining the output value

End Function

Or, if the query is defined somewhere outside, for e.g.:

getCol1data = UCASE("SELECT 'searchColumnHere' FROM tableName WHERE columnName='value'") '"searchColumnHere" is the code name of the column which's value should be outputed. for e.g: CLBVAS (use from your select)

then the function can be wrote like this (I've added it within a class):

Public Function DBQuery

DBQuery = New Query

End Function

Class Query

Public Function DBSelect(sqlSelect, searchColumnHere)

set conn = createobject("adodb.connection")

conn.open "DSN=DSN_SERVERhere; UserID=userID; Password=password;"

set rs = createobject("adodb.recordset")

'get the date value from DB for an Event

rs.open sqlSelect, conn

eventsInDB = rs(searchColumnHere)

'eventsInDB = FormatNumber(eventsInDB, 2) - use this if you need to format the output number

rs.close

DBSelect = eventsInDB 'here we are defining the output value

End Function

End Class

now the function is called like this:

DBQuery.DBSelect getCol1data "searchColumnHere" 'the "getCol1data" has the value assigned to it upper

or:

DBSelect getCol1data "searchColumnHere" 'when there is no class defined

Create a function which returns a random number

2011-04-04T07:24:00.000-06:00

How to set a "randomValue" to a variable and How to run an UPDATE within a Data Base using this variable
'set a random number - this function will be called to do updates
Function RandomNr
upperbound = 1000-1
lowerbound = i
For i=1 to upperbound
Randomize
RndNr = Int((upperbound - lowerbound + 1) * Rnd + lowerbound)
Next
RandomNr = RndNr
End Function

DB Update using the "RandomNr" function above:
updateCol1data = UCASE("update tableName set ColumnHere = '" & RandomNr & "' WHERE columnName='value'")

'querying an 'UPDATE' for a fields within DB
Public Function DBUpdate(updateCol1data)
set conn = createobject("adodb.connection")

conn.open "DSN=DSN_SERVERhere; UserID=userID; Password=password;"

conn.Execute updateCol1data
End Function

Now to call this function use next:
DBUpdate updateCol1data

Descriptive Programming

2011-03-08T18:03:00.000-07:00

In this post we'll discuss about:

Introduction to Descriptive Programming.
How to write Descriptive Programming?When and Where to use Descriptive programming?
Some points to note with Descriptive Programming.

Introduction to Descriptive Programming:Descriptive programming is used when we want to perform an operation on an object that is not present in the object repository. There can be various valid reason to do so. We will discuss them later in this article.

How to write Descriptive Programming?

There are two ways in which descriptive programming can be used

1. By giving the description in form of the string arguments.

2. By creating properties collection object for the description.

1. By giving the description in form of the string arguments.

This is a more commonly used method for Descriptive Programming.

You can describe an object directly in a statement by specifying property:=value pairs describing the object instead of specifying an object’s

name. The general syntax is:

TestObject("PropertyName1:=PropertyValue1", "..." , "PropertyNameX:=PropertyValueX")

TestObject — the test object class could be WebEdit, WebRadioGroup etc….

PropertyName:=PropertyValue — the test object property and its value. Each property:=value pair should be separated by commas and quotation

marks. Note that you can enter a variable name as the property value if you want to find an object based on property values you retrieve during a run session.

Consider the HTML Code given below:

<--!input type="”textbox”" name="”txt_Name”"-->
<--!input type="”radio”" name="”txt_Name”"-->

Now to refer to the textbox the statement would be as given below

Browser(“Browser”).Page(“Page”).WebEdit(“Name:=txt_Name”,”html tag:=INPUT”).set “Test”

And to refer to the radio button the statement would be as given below

Browser(“Browser”).Page(“Page”).WebRadioGroup(“Name:=txt_Name”,”html tag:=INPUT”).set “Test”

If we refer to them as a web element then we will have to distinguish between the 2 using the index property

Browser(“Browser”).Page(“Page”).WebElement(“Name:=txt_Name”,”html tag:=INPUT”,”Index:=0”).set “Test” ‘Refers to the textbox
Browser(“Browser”).Page(“Page”).WebElement(“Name:=txt_Name”,”html tag:=INPUT”,”Index:=1”).set “Test” ‘Refers to the radio button

To determine which property and value pairs to use, you can use the Object Spy:

1. Go to Tools -> Object Spy.

2. Select the "Test Object Properties" radio button.

3. Spy on the desired object.

4. In the Properties list, find and write down the properties and values that can be used to identify the object.

2. By creating properties collection object for the description.
Properties collection also does the same thing as string arguments. The only difference is that it "collects" all the properties of a particular object in an instance of that object. Now that object can be referenced easily by using the instance, instead of writing "string arguments" again and again. It is my observation that people find "string arguments" [1] method much easier and intuitive to work with.
To use this method you need first to create an empty description

Dim obj_Desc ‘Not required to be declared
Set obj_Desc = Description.Create

Now we have a blank description in “obj_Desc”. Each description has 3 properties “Name”, “Value” and “Regular Expression”.

obj_Desc(“html tag”).value= “INPUT”

When you use a property name for the first time the property is added to the collection and when you use it again the property is modified. By default each property that is defined is a regular expression. Suppose if we have the following description

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt.*”

This would mean an object with html tag as INPUT and name starting with txt. Now actually that “.*” was considered as regular expression. So, if you want the property “name” not to be recognized as a regular expression then you need to set the “regularexpression” property as FALSE

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt.*”
obj_Desc(“name”).regularexpression= “txt.*”

This is how we create a description. Now below is the way we can use it

Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test”

When we say .WebEdit(obj_Desc) we define one more property for our description that was not earlier defined that is it’s a text box (because QTPs WebEdit boxes map to text boxes in a web page).

If we know that we have more than 1 element with same description on the page then we must define “index” property for the that description

Consider the HTML code given below

<--!input type="”textbox”" name="”txt_Name”"-->
<--!input type="”textbox”" name="”txt_Name”"-->

Now the html code has two objects with same description. So distinguish between these 2 objects we will use the “index” property. Here is the description for both the object

For 1st textbox:

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
obj_Desc(“index”).value= “0”

For 2nd textbox:

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
obj_Desc(“index”).value= “1”

Consider the HTML Code given below:

<--!input type="”textbox”" name="”txt_Name”"-->
<--!input type="”radio”" name="”txt_Name”"-->

We can use the same description for both the objects and still distinguish between both of them

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”

When I want to refer to the textbox then I will use the inside a WebEdit object and to refer to the radio button I will use the description object with the WebRadioGroup object.

Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test” ‘Refers to the text box
Browser(“Browser”).Page(“Page”).WebRadioGroup(obj_Desc).set “Test” ‘Refers to the radio button

But if we use WebElement object for the description then we must define the “index” property because for a webelement the current description would return two objects.

Getting Child Object:

We can use description object to get all the objects on the page that matches that specific description. Suppose we have to check all the checkboxes present on a web page. So we will first create an object description for a checkboxe and then get all the checkboxes from the page

Dim obj_ChkDesc

Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”

Dim allCheckboxes, singleCheckBox

Set allCheckboxes = Browse(“Browser”).Page(“Page”).ChildObjects(obj_ChkDesc)

For each singleCheckBox in allCheckboxes

singleCheckBox.Set “ON”

The above code will check all the check boxes present on the page. To get all the child objects we need to specify an object description.

If you wish to use string arguments [1], same thing can be accomplished by simple scripting.

Code for that would be:

i=0
Do While Browse(“Browser”).Page(“Page”).WebCheckBox("html tag:=INPUT",type:=checkbox, "index:="&i).Exist

Browse(“Browser”).Page(“Page”).WebCheckBox("html tag:=INPUT",type:=checkbox, "index:="&i).Set "ON"
i=i+1

Loop

Possible Operation on Description Objects

Consider the below code for all the solutions

Dim obj_ChkDesc

Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”

Q: How to get the no. of description defined in a collection

A: obj_ChkDesc.Count ‘Will return 2 in our case

Q: How to remove a description from the collection

A: obj_ChkDesc.remove “html tag” ‘would delete the html tag property from the collection

Q: How do I check if property exists or not in the collection?

A: The answer is that it’s not possible. Because whenever we try to access a property which is not defined its automatically added to the collection. The only way to determine is to check its value that is use a if statement “if obj_ChkDesc(“html tag”).value = empty then”.

Q: How to browse through all the properties of a properties collection?

A: Two ways:

1st:

For each desc in obj_ChkDesc
Name=desc.Name
Value=desc.Value
RE = desc.regularexpression
Next

2nd:

For i=0 to obj_ChkDesc.count - 1
Name= obj_ChkDesc(i).Name
Value= obj_ChkDesc(i).Value
RE = obj_ChkDesc(i).regularexpression
Next

Hierarchy of test description:

When using programmatic descriptions from a specific point within a test object hierarchy, you must continue to use programmatic descriptions from that point onward within the same statement. If you specify a test object by its object repository name after other objects in the hierarchy have been described using programmatic descriptions, QuickTest cannot identify the object.

For example, you can use Browser(Desc1).Page(Desc1).Link(desc3), since it uses programmatic descriptions throughout the entire test object hierarchy.
You can also use Browser("Index").Page(Desc1).Link(desc3), since it uses programmatic descriptions from a certain point in the description (starting from the Page object description).

However, you cannot use Browser(Desc1).Page(Desc1).Link("Example1"), since it uses programmatic descriptions for the Browser and Page objects but then attempts to use an object repository name for the Link test object (QuickTest tries to locate the Link object based on its name, but cannot locate it in the repository because the parent objects were specified using programmatic descriptions).

When and Where to use Descriptive programming?

Below are some of the situations when Descriptive Programming can be considered useful:

1. One place where DP can be of significant importance is when you are creating functions in an external file. You can use these function in various actions directly , eliminating the need of adding object(s) in object repository for each action[If you are using per action object repository]

2. The objects in the application are dynamic in nature and need special handling to identify the object. The best example would be of clicking a link which changes according to the user of the application, Ex. “Logout <>”.

3. When object repository is getting huge due to the no. of objects being added. If the size of Object repository increases too much then it decreases the performance of QTP while recognizing a object. [For QTP8.2 and below Mercury recommends that OR size should not be greater than 1.5MB]

4. When you don’t want to use object repository at all. Well the first question would be why not Object repository? Consider the following scenario which would help understand why not Object repository
Scenario 1: Suppose we have a web application that has not been developed yet.Now QTP for recording the script and adding the objects to repository needs the application to be up, that would mean waiting for the application to be deployed before we can start of with making QTP scripts. But if we know the descriptions of the objects that will be created then we can still start off with the script writing for testing

Scenario 2: Suppose an application has 3 navigation buttons on each and every page. Let the buttons be “Cancel”, “Back” and “Next”. Now recording action on these buttons would add 3 objects per page in the repository. For a 10 page flow this would mean 30 objects which could have been represented just by using 3 objects. So instead of adding these 30 objects to the repository we can just write 3 descriptions for the object and use it on any page.

5. Modification to a test case is needed but the Object repository for the same is Read only or in shared mode i.e. changes may affect other scripts as well.

6. When you want to take action on similar type of object i.e. suppose we have 20 textboxes on the page and there names are in the form txt_1, txt_2, txt_3 and so on. Now adding all 20 the Object repository would not be a good programming approach.

References..

The complete list of new features that are available in QTP 11

2011-02-22T17:42:00.000-07:00

XPath and CSS based object identification

Identify objects not only using normal object identification but with XPath and CSS identifier properties. A much awaited and a killer feature.

Good Looking and Enhanced Results Viewer

The new improved results viewer provides an executive summary page with summary data, pie charts and statistics for both the current and previous runs and a quick link to the previous run results.

Easy Regular Expressions

You can now create reg ex with the help of syntax hints. Regular Expression Evaluator is available to test regular expressions that you have created. Good One.

Now identify objects not only in relation to each other but in relation to neighboring objects.

With this feature, QTP 11 has moved beyond the unreliability of ordinal identifiers. Objects identified with ordinal identifiers are good only as long as they maintain their relative positions with respect to each other in the new build of application. In case if this position changes or gets interchanged, ordinal identifiers may go for a toss.
HP has now introduced Visual Relation Identifier.

A visual relation identifier is a set of definitions that enable you to identify the object in the application according its neighboring objects in the application. You can select neighboring objects that will maintain the same relative location to your object, even if the user interface design changes. You define visual relations in the Visual Relation Identifier dialog box, which is accessible from the local or shared object repository, and from the Object Properties dialog box.

Load Function Libraries at Run Time

With the help of LoadFunctionLibrary statement. You can now load a function library when a step runs instead of at the beginning of a run session.

Test Your GUI and UI-Less Application Functionality in One Test

Since QTP is integrated with Service Test, you can now test your GUI and non-GUI based apps in a single run.

Record Support

For FireFox is now available.

Much Awaited Log Tracking is available now

QTP 11 is capable of receiving Java or .NET log framework messages from your application which can then be embedded in the run results.

Embed/Run Javascript in web pages

You can use the new EmbedScript/EmbedScriptFromFile andRunScript/RunScriptFromFile functions to embed JavaScripts in all loaded browser pages. You can use these scripts to perform operations on, or retrieve data from, the browser pages in your application.

Manage Test Data

Improved test data management when integrated with Quality Center

Web 2.0 Toolkit Applications Support

QTP 11 now supports Web 2.0 Toolkit Applications out-of-the-box similar to any other add-ins.

Automatically Parameterize Steps

You can instruct QTP 11 to automatically parameterize test steps at the end of record session.

Silverlight Add-in

To test objects in Silverlight 2 and Silverlight 3 applications. [After installation, Silverlight Add-in is displayed in the Add-in Manager as a child add-in under the WPF Add-in]

Extend WPF and Silverlight Support

You can use WPF and Silverlight Add-in Extensibility SDK to develop support for testing third-party and custom WPF and Silverlight controls that are not supported out-of-the-box

Use Extensibility Accelerator for Web Add-in Extensibility Development

Avoid Downtime Due to License Server Failures

Useful for concurrent license users. With redundant license serversyou can create failover, so that if your main license server fails, your remaining servers maintain availability of your licenses without causing any downtime or loss of licenses for users.

You can get more information on HP Functional Testing 11 here and download it here.

QTP 11 available for download.

2011-01-28T17:25:00.000-07:00

HP has packaged QTP 11, all its add-ins and HP Service Test under the heading of HP Functional Testing 11. You can download the entire package here (iso file, 3.61 GB). QTP 11 is available as a 30 days trial unlike its predecessors which were only available for 14 days. (New users need to register on HP’s site. No contract/maintenance required to download trial )

Unfortunately, this means, QTP 10.0 will no longer be available from HP’s download center.

Check the complete list of new features in QTP 11.

Difference between QTP8.2 and QTP9.0/QTP9.2

2011-01-19T06:11:00.000-07:00

Over and above features provided with QTP 9.0 , QTP 9.2 provides following features:
Mercury Screen Recorder :
Capture your entire run session in a movie clip or capture only the segments with errors, and then view your movie from the Test Results window.

Dynamic Management of Object Repositories:
QuickTest now has a new RepositoriesCollection reserved object that you can use to programmatically manage the set of object repositories that are associated with an action during a run session.

Over and above features provided with QTP 8.2 , QTP 9.0 provides following features:

Object Repository Manager:
You can use the Object Repository Manager to manage all of the shared object repositories in your organization from one, central location. This includes adding and defining objects, modifying objects and their descriptions, parameterizing test object property values, maintaining and organizing repositories, and importing and exporting repositories in XML format.

You can open multiple object repositories at the same time. Each object repository opens in its own resizable document window. This enables you to compare the content of the repositories, to copy or move objects from one object repository to another, and so forth.

Object Repository Merge Tool:
You can use the Object Repository Merge Tool to merge the objects from two shared object repositories into a single shared object repository. You can also use the Object Repository Merge Tool to merge objects from the local object repository of one or more actions or components into a shared object repository.

When you merge objects from two source object repositories, the content is copied to a new, target object repository, ensuring that the information in the source repositories remains unchanged.

If any conflicts occur during the merge, for example, if two objects have the same name and test object class, but different test object descriptions, the relevant objects are highlighted in the source repositories, and the Resolution Options pane details the conflict and possible resolutions.

Multiple Object Repositories per Action or Component:
QuickTest provides several options for storing and accessing test objects. You can store the test objects for each action or component in its corresponding local object repository, which is unique for each action and component. You can also store test objects in one or more shared object repositories that can be used in multiple actions and components. Alternatively, you can use a combination of objects from the local object repository and one or more shared object repositories. You choose the combination that matches your testing needs.

XML Object Repository Format:
QuickTest now enables you to import and export object repositories from and to XML format. This enables you to modify object repositories using the XML editor of your choice and then import them back into QuickTest. You can import and export files either from and to the file system or a Quality Center project (if QuickTest is connected to Quality Center).

Function Library Editor:
QuickTest now has a built-in function library editor, which enables you to create and edit function libraries containing VBScript functions, subroutines, modules, and so forth, and then call their functions from your test or component.

Handling Missing Actions and Resources:
Whenever a testing document (test, component, or application area) contains a resource that cannot be found, QuickTest opens the Missing Resources pane and lists the missing resource(s). For example, a test may contain an action or a call to an action that cannot be found; a testing document may use a shared object repository that cannot be found; or a testing document may use a object repository parameter that does not have a default value. In all of these cases, QuickTest indicates this in the Missing Resources pane, enabling you to map a missing resource to an existing one, or remove it from the testing document, as required.

Source:

QTP's Global Settings and Options

2010-12-06T04:03:00.000-07:00

To set global testing options Choose Tools > Options or click the Options toolbar button.

The Options dialog box opens. It is divided by subject into several tabbed pages:

General tab:

The General tab options affect the general appearance of QTP and other general testing options.

Note: The Web tab shown in the dialog box is displayed only if the Web Add-in is installed and loaded.

Description:

General tab includes the following options:

Display Add-in Manager on startup: Determines whether the Add-in Manager is displayed when starting QuickTest.
Display Start Page on startup: Determines whether the Welcome screen is displayed when starting QuickTest.
Check for software updates on startup: Determines whether the QTP will check for any software updates when it starts.
Disable recognition of virtual objects while recording: Determines whether the defined virtual objects stored in the Virtual Object Manager are recognized while recording.
Automatically update test and component steps when you rename test objects: Instructs QTP to update any test components if there where any changes or renamed test objects (actions, folder’s paths renaming...)
Automatically generate “With” statements after recording: Instructs QuickTest to automatically generate ”With” statements when we record.
Generate “With” statements for __ or more objects: Indicates the minimum number of identical, consecutive objects for which we want to apply the With statement. This setting is used when QuickTest automatically generates With statements after recording and when you select to generate With statements for an existing action. Default = 2.
When pointing at a window, activate it after __ tenths of a second: Specifies the time (in tenths of a second) that QuickTest waits before it sets the focus on an application window when using the pointing hand to point to an object in the application (for Object Spy, checkpoints, Step Generator, Recovery Scenario Wizard, and so on). Default = 5.
Use text recognition mechanisms in this order ____: Instructs QTP which mechanism to be used when it’s retrieving any text from an object.
Restore Layout: Restores the layout of the QuickTest window so that it displays the panes in their default sizes and positions.
Generate Script: Generates an automation script containing the current global testing options.

Folder tab:

The Folders tab enables us to enter the folders (search paths) in which QuickTest searches for tests, actions, or files that are specified as relative paths in dialog boxes and statements. For example, suppose we add the folder in which all of our tests are stored to the folders list. If we later insert a copy of an action to a test, we only have to enter the name of the test containing the action we want to insert in the Insert Copy of Action dialog box. QuickTest searches for the test’s path in the folders we specified in the Folders tab.

Note: The component is listed in the Search list by default. It cannot be deleted.

The order in which the folders are displayed in the search list determines the order in which QuickTest searches for the specified test, component, action, or file.

Description:

The Folders tab includes the following options:

Search List: Indicates the folders in which QuickTest searches for tests, actions, or files. If you define folders here, you do not need to designate the full path of a test, component, action, or file in other dialog boxes or call statements. The order of the search paths in the list determines the order in which QuickTest searches for a specified action or file.

Adds a new folder to the search list.

Tip: To add a Quality Center path when connected to Quality Center, click this button. QuickTest adds [QualityCenter], and displays a browse button so that you can locate the Quality Center path. When not connected to Quality Center, hold the SHIFT key and click this button. QuickTest adds [QualityCenter], and you enter the path. You can also type the entire Quality Center path manually. If you do, you must add a space after [QualityCenter]. For example: [QualityCenter] Subject\Tests. Note that QuickTest searches Quality Center project folders only when you are connected to the corresponding Quality Center project.

Deletes the selected folder from the search list.

Moves the selected folder down/up in the list.

Tip: You can use a PathFinder.Locate statement in your test to retrieve the complete path that QuickTest will use for a specified relative path based on the folders specified in the Folders tab. For more information, refer to the QuickTest Professional Object Model Reference.

Active Screen tab:

The Active Screen tab enables us to specify which information QuickTest saves and displays in the Active Screen while recording and running tests and components.

Tip: The more information saved in the Active Screen, the easier it is to edit the test or component after it is recorded. However, more information saved in the Active Screen adds to the recording time and disk space required. This is especially critical in Visual Basic, ActiveX, and .NET Windows Forms environments. You can increase or decrease the amount of information saved in your test or component after it is recorded.

Note: When you are recording on an MDI (Multiple Document Interface) application, the Active Screen does not capture information for non-active child frames.

Custom Active Screen Capture Settings

Active Screen - Web Page Appearance

Description:
Active Screen tab includes the following options:

Capture Level: Specifies the objects for which QuickTest stores data in the Active Screen. Use the slider to select one of the following options:

Complete — Captures all properties of all objects in the application’s active window/dialog box/Web page in the Active Screen of each step. This level saves Web pages after any dynamic changes and saves Active Screen files in a compressed format.
Partial — (Default). Captures all properties of all objects in the application’s active window/dialog box/Web page in the Active Screen of the first step performed in an application’s window, plus all properties of the recorded object in subsequent steps in the same window. This level saves Web pages after any dynamic changes and saves Active Screen files in a compressed format.
Minimum — Captures properties only for the recorded object and its parent in the Active Screen of each step. This level saves the original source HTML of all Web pages (prior to dynamic changes) and saves Active Screen files in a compressed format.
None — Disables capturing of Active Screen files for all applications and Web pages.
Custom Level: Enables us to specify custom Active Screen options.
Default Level: Return the capture level settings to the predefined default level (Partial).
Advanced: Enables us to define the appearance of Web pages in the Active Screen.

Run tab:

The Run tab options affect how QTP runs tests and components and displays test results.

Description:

Run tab includes the following options:

Run mode: Instructs QuickTest how to run your test or component:

Normal (displays execution marker) — Runs your test or component with the execution arrow to the left of the Keyword View or Expert View, marking each step or statement as it is performed. If the test contains multiple actions, the tree in the Keyword View Item column expands to display the steps, and the Expert View displays the script, of the currently running action. This option requires more system resources.

Note: You must have Microsoft Script Debugger installed to enable this mode. For more information, refer to the QuickTest Installation Guide.

Fast — Runs your test or component without the execution arrow to the left of the Keyword View or Expert View and does not expand the item tree or display the script of each action as it runs. This option requires fewer system resources.

Submit a defect to Quality Center for each failed step: Instructs QuickTest to automatically submit a defect to Quality Center for each failed step in your test or component. This option is available only when you are connected to a Quality Center project.
View results when run session ends: Instructs QuickTest to display the results automatically following the run session.
Allow other HP products to run tests and components: Enables other Mercury products such as Quality Center and Test Batch Runner to run QuickTest tests and components. This option is not required to enable WinRunner to run QuickTest tests and components.
Save still image capture to results: Instructs QuickTest when to capture and save images of the application during the run session to display them in the results. Choose an option from the list:

Always — Captures images of each step, whether the step fails or passes.

For errors — Captures images only if the step fails.

For errors and warnings — Captures images only if the step returns a failed or warning status.

Save movie to results: Instructs QTP when to register the application during the run session. Choose an option from the list:

Always — Captures images of each step, whether the step fails or passes.

For errors — Captures images only if the step fails.

For errors and warnings — Captures images only if the step returns a failed or warning status.

It’s possible to set the max length of the movie or to set record for the entire test run.

Windows Applications tab:

The Windows Applications tab options allow you to configure how QuickTest records and runs tests and components for Standard Windows, ActiveX, .NET Windows Forms, and Visual Basic applications.

Windows Applications tab - Advanced view

Description:

Windows Applications tab includes the following options:

Attached Text: Enables you to specify the search criteria that QuickTest uses to retrieve an object’s attached text. An object’s attached text is the closest static text within a specified radius from a specified point. The retrieved attached text is saved in the object’s corresponding text or attached text test object property.
Note: Sometimes the static text that you believe to be closest to an object is not actually the closest static text. You may need to use trial and error to make sure that the attached text is the static text object of your choice.

Search radius — Indicates the maximum distance, in pixels, that QuickTest searches for attached text.

Search area — Indicates the point on an object from which QuickTest searches for the object’s attached text.

Choose an option from the list:

• Top-Left—top-left corner

• Top—midpoint of the two top corners

• Top-Right—top-right corner

• Right—midpoint of the two right corners

• Bottom-Right—bottom-right corner

• Bottom—midpoint of the two bottom corners

• Bottom-Left—bottom-left corner

• Left—midpoint of the two left corners

Open menu to retrieve item properties: Instructs QuickTest to open menu objects before retrieving menu item properties during a run session.
Note: Selecting this option may slow the run, but it can be useful if menu item properties change upon opening the menu. This option, selected by default, sets the default behavior for all menu objects. You can use the ExpandMenu method to set this behavior for a specified menu object.
Record non-unique list items: Determines what QTP records when more than one item (in a list or tree) has an identical name:

by name – Records the item’s name. When the test or component runs, QTP finds and selects the first instance of the name, no matter which item was chosen during recording. Select this option if the all items with the same name have identical properties.

by index – Records the item’s index number. Select this option if items with the same name do not necessarily have identical properties.

Record owner – drawn button as: Instructs QTP how to identify and record custom-made buttons in the application. Choose an option from the list:

push button;

check boxes;

radio buttons;

objects;

Advanced: Opens "Advanced Windows Applications Options" dialog box, where you can customize record and run options for our Windows applications.

Pre-requisites for QTP Automation Process

2010-11-28T05:35:00.000-07:00

The following are pre-requisites or dependencies for QTP automation process:

Knowledge and hands-on experience with the use of QTP;
Quality Centre (QC) and QTP installed and configured;
QC and QTP are integrated;
QTP Add-Ins are installed (if required);
QC user groups are defined and granted access to Quality Centre projects;
The application or product is in a stable state;
Creation of new automated scripts requires existing manual test cases to have been executed successfully. This task is performed by the application tester or business representative and is performed prior to handover to QTP automation.
The manual test cases must have been executed successfully and that there are no other changes in the application. Existing automated scripts can be updated directly to reflect the changes as part of maintenance releases.
All test cases must start and end at the same point. This is normally the First screen of the application. This allows for test cases to be batched together into a test suite.
All environment, software or data table changes must be advised to the automated testing team. There will potentially be an impact on the running of automated test cases with the introduction of these changes.
The test cases must not be data dependant. All data required in the test case must be created in the test case. In the event that data cannot be created and the test case is data dependant, the data must be able to be restored, or manipulated back to the initial state after a test case updates the data. This then allows for any test case to be rerun at anytime.

Introduction to QTP

2010-11-14T02:12:00.000-07:00

What QTP means?
   Quick Test Professional – is widely / most popularly used as Functional and Regression Test Automation Tool. It was initially developed by Mercury Interactive and then acquired by HP.
   Quick Test Professional – captures, verifies and replays user interactions automatically and helps testers quickly identify and report on application effects, while providing advanced functionality for tester collaboration.
   Quick Test Professional – the user friendly IDE which has Keyword view, Expert view, DataTable, Active screen, object repository editor/manager, step generator, function generator, object highlight feature, intelligence, recovery scenario manager, update run feature and simple Test/Action handling features makes the Script developing/execution work easy. The IDE is integrated with useful tools such as ObjectSpy. The IDE has standard development features such as Debug.
   Quick Test Professional – supports Windows and Web based Applications.

Why QTP?

Ease of use:

QTP allows even novice testers to be productive in minutes. You can create a test script by simply pressing a Record button and using an application to perform a typical business process.
Using the Active Screen facility, several types of checkpoints for any object to verify the components behave as expected can be created simply by clicking on the object in the Active Screen.
Data Table, an integrated spreadsheet with the full functionality of Excel, is used to manipulate data sets and create multiple test iterations, without programming, to expand test case coverage.

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

QTPKey Features

Mercury Screen Recorder – Captures your entire run session in a movie clip or capture only the segments with errors, and then view your movie from the Test Results window.

Dynamic Management of Object Repositories – Programmatically manage an action’s shared object repository collection during the test run.

Keyword view – Lets you easily build and maintain tests writing VBScripts.

Auto-Documentation – Provides improved test clarity and the ability to view test steps in plain English

Step Generator – Allows quickly insert custom-built functions into your tests.

Enhanced Object Spy functionality – When you hover over objects in your application using the pointing hand, you can view their proprieties, methods and object hierarchy in the object spy. As you hover over each object, it is highlighted in the application.

Mercury Business Process Testing – Enhanced integration with BPT – Business Components, Script Components and Application Areas.

Action Parameters – Allows you to generalize testing actions for greater reusability.

Data Parameters – You can now specify test or action parameters to pass values into and from your test, and between actions in your test.

Open XML Report Format for Test Results – Test Results are now stored in open XML format, enabling you to easily customize the reports according to your own requirements, and to integrate the test results information with applications.

Unicode Support – Lets you test global deployment of your enterprise applications.

Function Definition Generation – You can use the new function Definition Generator to generate definitions for user- defined function, add header information to them and register function to a test object.

Tools support for QTP

VB Script for Scripting (for implementing programming logic)
VB Script engine integrated in QTP, so apart from scripting features we can use File system, Excel, word, AdoDB etc. object models from QTP
SQL (Structured query language) engine integrated in QTP, so we can use SQL Statements in QTP to perform Database Operations
Excel like spread sheet integrated in QTP for performing Data driven Testing
We can install MS Script Debugger with QTP for Debugging Test scripts
QTP uses XML format also for Environment variables and for exporting object repositories
QTP can be integrated with other Tools like WinRunner and Quality Center
QTP can be used for user interface (UI) test case automation and some limited (Non UI) Test case automation like File system operations and Data base operations
It was derived from Astra QuickTest (mother tool of QTP)
It supports IE (Internet Explorer) only for recording tests, for execution it supports other browsers like Mozilla and AOL, opera Etc apart from IE
QTP is a Desktop Application (I-Tier/Stand alone)
QTP developed in .NET Technology
Since it is Stand-alone Application, It doesn't have Database, It stores resources as files (Internal and External). We can't share QTP services from one machine to another, but we can’t share resources (Ex: Object Repository files, Function Libraries, Environment variable files, Recovery scenario files etc...)

Version History of QTP

Astra QuickTest (Mother tool of QTP) 1.0 to 5.0

* QTP derived from Astra QuickTest and influenced by WinRunner.

Quick Test Professional

5.6 – Nov 2002
6.5 – 2003
8.0 – 2004
8.2, 8.3 –2005
9.0,9.1-2006
9.2- 2007 Mercury Interactive
9.5 –2008 H.P
10.00 –2009 January
11.00 –2010** (It is the Latest Version)

First POST!

2010-11-03T07:16:00.001-06:00

Hi All,
This blog was created on 03.11.2010.

WELCOME
Here I will share all my knowledge about QTP with all of you
I hope you'll realy like my blog and it will help you to solve all your issues.
!!! ENJOY !!!