Before you install the trial license, make sure that you have gone through all the pre-requisites mentioned in the previous article. After you have done so, start installing UFT 11.5 till you reach the final step where the installation of UFT 11.5 is complete. After that, follow the below video, which provides a detailed explanation on how you can use the 30-Day trail seat license in UFT 11.5

If you face any issues with the download or installation process, you can get in touch with us through email or using the comments section.

For more QTP Tutorials, you can visit our QTP Tutorials page. You can also visit our Download Page to view all the downloadable content.

Before you install UFT 11.5

1) Make sure that you have administrator privileges on the drive to which you want to install UFT 11.5.

2) Make sure that you have Internet Explorer 7.0 or later installed on your machine.

3) You can use UFT 11.5 trial version only if you are installing this for the first time in your system. If you have previously installed any other version of QTP in your system, the trial version of UFT 11.5 will not work (UFT will ask for a license when you try to open it)

4) If you have QTP 9.5 or later or Service Test 10.0 or later, then the installation process will first uninstall QTP or Service Test’s older version and will then install UFT 11.5. If you have QTP 9.2 installed on your system, then you must manually uninstall it before installing UFT 11.5.

Step by Step process to install UFT 11.5

You can either refer the below video or check the step by step process (given below the video) on how to install UFT 11.5.

1) Once you download UFT 11.5, the downloaded file will be available to you as a .zip file. The first step would be to extract the .zip file.

2) Open the unzipped folder and locate setup.exe.

3) Open setup.exe to start the installation process. You would be navigated to a screen as shown in the below image.

4) Click on Unified Functional Testing Setup link. You would be navigated to the Welcome Screen as shown below.

5) Click on Next button from the Welcome Screen. You will then be taken to the License Agreement screen.

6) Select ‘I Agree‘ and then click on Next button. You will be now taken to ‘Customer Information’ screen.

7) Upon clicking the Next button, you will be taken to Custom Setup (Add-Ins) Screen.

8 ) Select the required Add-ins and click on Next button. You would be taken to Select Installation Folder screen.

9) Provide appropriate installation path and click on Next button. You would be taken to the Confirm Installation screen as shown below.

10) Upon clicking the Next button, the installation process will begin. The entire installation process may take 15-20 minutes to complete. Once the installation process is complete, you will be taken to the Installation Complete screen as shown below.

11) Click on Finish button. After this, Additional Installation Requirements Screen will be displayed.

12) Select the first two check boxes. If you don’t have a valid license for UFT 11.5 (i.e. you want to install the trial version), uncheck the 3rd check box. Click on Run button. Once the additional installations are completed, you will be taken to a screen as shown below.

Installation of UFT 11.5 is now complete. You can now close the Additional Installation Requirements window and start using UFT 11.5.

If you face any issues with the download or installation process, you can get in touch with us through email or using the comments section.

For more QTP Tutorials, you can visit our QTP Tutorials page. You can also visit our Download Page to view all the downloadable content.

You can either check the below video or follow the step by step approach (provided after the video) to download UFT 11.5 from HP website.

Steps to Download UFT (QTP) 11.5 from HP website

1) Go to UFT 11.5 download link. You will be navigated to the page shown in the below screenshot.

2) Click on the trial software section to expand it. Once expanded, you will see the links for various trial software that are currently available for download.

3) Click on ‘HP Unified Functional Testing 11.50 CC English SW E-Media Evaluation’ link. You would be taken to a page where you would need to provide your personal details as shown below.

4) Enter all the mandatory details and then click on Next button at the bottom of the page. If all the details are filled in correctly, you will be navigated to the ‘Terms of Service’ screen as shown below.

5) Click on “I Agree” to move to the main download screen as shown in the below image.

6) Click on the Download link to download the software. The software will be downloaded as a ZIP file.

As shown in the above image also, the size of UFT 11.5 is around 1.7GB. Downloading the software will take 1-2 hours (depending upon the internet speed).

Related Article: Installing UFT 11.5 Trial Version

In case you face any issues while downloading UFT 11.5, please feel free to contact us using email or using the comments section.

For more QTP Tutorials, you can visit our QTP Tutorials page. You can also visit our Download Page to view all the downloadable content.

1) What is UFT 11.5?

The new version of HP QTP is being called HP Unified Functional Testing 11.5 (UFT 11.5). UFT 11.5 is actually a combination of HP QTP (for testing GUI) and HP Service Test (for testing API).

2) Brand New Modern IDE

This point has been discussed so many times at many forums. QTP’s IDE lacked the punch when compared to many modern IDE’s like Eclipse, Microsoft Visual Studio etc. It lacked many must have features that were there in many IDEs available in the market. With UFT 11.5, HP will be introducing a brand new modern IDE, which will

a) have a new IDE aligned with modern dev IDEs (like Eclipse).

b) have many new features such as script editing, coding, MDI, checkpoints, auto completion etc

Image Courtesy: HP Webinar Slides

3) Image Based Automation – Using HP UFT Insight

With what I have understood, this seems to be a real killer. HP claims that, using HP UFT insight, you can simply recognize controls in the application by their appearance. This feature would enable you to record any object displayed on the screen, even if UFT is not able to recognize the Object’s technology.

Image Courtesy: HP Webinar Slides

4) Integration with Open Source CI Systems

This is another very good feature that has been implemented in UFT 11.5. This was one of the key drawbacks due to which QTP was not considered a good tool for automation in Agile Projects. With this new feature, you would be able to -

a) integrate UFT with popular CI systems like Jenkins.

b) automatically execute smoke and regression test cases repeatedly as part of nightly builds.

5) HP UFT Mobile – Extended Support for Mobile Testing

As part of UFT 11.5, HP will be providing lot of new features in mobile testing, where you will be able to -

a) write agnostic scripts, which once written can be used on multiple devices.

b) test your scripts on simulators as well as real devices.

Image Courtesy: HP Webinar Slides

Apart from these major features, there are lots of other features such as pdf checkpoints, graphic UI – canvas, workflows support thanks to integration to QC / ALM, support for latest technologies – Qt apps, Flex, more than 20 new versions etc.

All these new features can be explored when HP releases the trial version of UFT 11.5. The trial version should be available by the end of December 2012.

Update: The trial version of the software is now available for download. Refer UFT 11.5 download link to see detailed step by step process to download UFT 11.5.

For more information on the above points, refer the HP Webinar Slides.

Over to you

What are your thoughts on this new version? Were you looking out for any specific features, that has been included/not included in the latest version? Use the comments section to let us know what you think about this new version.

For more QTP Tutorials, you can visit our QTP Tutorials page. You can also visit our Download Page to view all the downloadable content.

This article contains the basic information about ‘Actions in QTP’. The main points that you would read in this presentation is listed below.

1) What are QTP Actions

2) What are the different types of QTP actions

3) How actions access data from QTP data tables

4) How to call actions in your QTP scripts

Refer below presentation for more details on the above mentioned points.

For more presentations on various QTP topics, refer this link.


If you are unable to view the presentation due to any reason, you can download it from the below link.

Actions in QTP – The Basics

For more QTP Tutorials, you can visit our QTP Tutorials page. You can also visit our Download Page to view all the downloadable content.

Topics that will be covered in this article

We will be covering the following topics in this article -

1) Identifying the components that will be used in this framework.

2) Identifying the test cases that will be automated as part of this framework.

3) Describing the process which would be used to write test scripts in this framework.

4) Enhancements/Improvement points for the framework.

Let us now see each of these topics one by one.

Components that will be used in this Framework

Following are the components that we will use to create this framework from scratch.

1) QTP Test Scripts (or QTP Actions): As part of this framework creation, we will be automating 3 test cases. And for each of these test cases, we will create a separate QTP Test Script.

2) Function Library: There will be 2 function libraries that will be created for this framework. The first function library will contain all the functions that are related only to the framework (and not to the application). The second function library will contain the functions that will contain the functions related to the application.

3) Object Repository: For this framework, we will use the Object Repository to store the object properties. Descriptive Programming will not be used anywhere in this framework.

4) Excel Sheet to Store Test Case Flow: We will be using a single excel workbook (and a single excel sheet in the workbook) to store the flow of all the 3 test cases.

Above mentioned are the 4 major components that will be used in this automation framework. Please note that the data for the test cases will be hard-coded in the test scripts only. Separate excel sheets will not be created to store data. The below figure shows the components and their flow.

Test Cases that will be automated for this Framework

For this framework, we will be working on the same test cases that were automated for Keyword Driven Framework mapped at Operation Level. The 3 test cases are -

1) TC_01_CreateOrder: For this test case, we will write a script that will login to Mercury Flight Reservation system and then create a new flight reservation.

2) TC_02_ModifyOrder: In this test case, the script will log in to the application, open an existing order and then modify the order.

3) TC_03_DeleteOrder: Here, the script will again log in to the application, open an existing order and then delete the order.

Step By Step Method to Automate the First Test Script

In this article, we will cover the creation of first test script in detail. And this test script will be created as per the framework specifications. Once you understand the underlying concepts used for creating the first script, you can use the same concepts to script the remaining test cases.

The below image depicts the basic steps which we will use to script the first test case from scratch.

Let us now cover each of these points in detail.

Step 1: Creating the First Test Script in QTP in Linear Manner

The first step would be to create the entire test script in the normal way (i.e. in the linear manner). For this, you can follow the steps mentioned below.

Step 1A: Open a new Test Case in QTP.

Step 1B: Navigate to Resources -> Object Repository Manager to open a new Object Repository.

Step 1C: Open the Flight Reservation Application (windows version) from Start -> All Programs -> QuickTest Professional -> Sample Applications -> Flight (this path may differ depending upon the OS and QTP Versions)

Step 1D: Add all the necessary objects (that are required for order creation) in the Object Repository.

Step 1E: Associate the Object Repository with the Test Script.

Step 1F: Once the Object Repository has been associated with the Test Script, write the script to insert a new order in the flight reservation system.

Step 1G: Run the script to verify that the code is working fine.

The code you have written to insert a new order in Flight Reservation System will look similar to the code shown below.

'===== Code to Login to the Application =====
SystemUtil.Run "C:\Program Files (x86)\HP\QuickTest Professional\samples\flight\app\flight4b.exe"
Dialog("Login").WinEdit("AgenName").Set "anish"
Dialog("Login").WinEdit("Password").Set "mercury"
Dialog("Login").WinButton("OK").Click

'===== Code to Insert a New Order =====
Set WshShell = CreateObject("WScript.Shell")
WshShell.SendKeys "%(fn)" 'Press Alt F+N to open new order screen
Window("Flight Reservation").ActiveX("DateOfFlight").Type "010114"
Window("Flight Reservation").WinComboBox("FlyFrom").Select "Paris"
Window("Flight Reservation").WinComboBox("FlyTo").Select "Sydney"
Window("Flight Reservation").WinButton("Flights").Click
'Select any Flight
Window("Flight Reservation").Dialog("FlightsTable").WinButton("OK").Click
'Provide Name and Insert Order
Window("Flight Reservation").WinEdit("Name").Set "Anish"
Window("Flight Reservation").WinButton("InsertOrder").Click

'===== Logout from Application =====
Window("Flight Reservation").Close

If your code to Insert New Order in Flight Reservation Application is running fine, then you have accomplished the first task. You now have the basic script that can insert a new order. Now all your remaining steps would focus on how to modify this script and fit it into the framework.

Step 2: Dividing the Script into Different Functions and calling them from the Test Script

In the previous step, you had created the test script in linear fashion. Now in this step, you would need to convert the linear flow into different functions and then call the same from the test script. To do this, you have to follow the steps mentioned below -

Step 2A: First Step is to identify the functions which should be created from the linear flow. One look at the test case, and you would get to know that the test case can be divided into 3 flows or functions. These are – Login, Insert Order and Logout.

Step 2B: Create 3 different functions in the Test Case and then cut paste the appropriate code in all the 3 functions. Example, the Login function will contain the code to login to the application.

Step 3B: Once all the functions have been created, call these functions from the test script itself. The code in the QTP test script should look something like this -

' - - Test Case Flow - -
fnLogin()
fnInsertOrder()
fnLogout()

'========================================
'   Function Name - fnLogin
'   Purpose - This function is used to login to flight reservation application
'========================================
Function fnLogin()

	SystemUtil.Run "C:\Program Files (x86)\HP\QuickTest Professional\samples\flight\app\flight4b.exe"
	Dialog("Login").WinEdit("AgenName").Set "anish"
	Dialog("Login").WinEdit("Password").Set "mercury"
	Dialog("Login").WinButton("OK").Click

End Function

'========================================
'   Function Name - fnInsertOrder
'   Purpose - This function inserts a new order in flight reservation application
'========================================
Function fnInsertOrder()

	Set WshShell = CreateObject("WScript.Shell")
	WshShell.SendKeys "%(fn)" 'Press Alt F+N to open a new order screen
	Window("Flight Reservation").ActiveX("DateOfFlight").Type "010114"
	Window("Flight Reservation").WinComboBox("FlyFrom").Select "Paris"
	Window("Flight Reservation").WinComboBox("FlyTo").Select "Sydney"
	Window("Flight Reservation").WinButton("Flights").Click
	'Select any Flight
	Window("Flight Reservation").Dialog("FlightsTable").WinButton("OK").Click
	'Provide Name and Insert Order
	Window("Flight Reservation").WinEdit("Name").Set "Anish"
	Window("Flight Reservation").WinButton("InsertOrder").Click

End Function

'========================================
'   Function Name - fnLogout
'   Purpose - This function is used to logout from the flight reservation application
'========================================
Function fnLogout()

	Window("Flight Reservation").Close

End Function

Step 2D: Run the code to verify that it is working fine.

In the beginning of the article, we had mentioned that we will be creating 2 function libraries in this framework. And one of these function libraries will be used to store the test case flow. So now, we will create a function library and then move the functions from the test script to this function library. This will be the function library that will contain the application related code.

Step 2E: Create a new function library and save it at an appropriate location.

Step 2F: Associate this function library to the QTP Test Script.

Step 2G: Cut paste the functions from the test script to the function library.

Now at this step, the function library will contain all the 3 functions and the test script will contain the function calls for all these 3 functions. The code in the test script and the function library will look something like this -

* * * * * Code in QTP Test Script * * * * *

fnLogin()
fnInsertOrder()
fnLogout()

* * * * * Code in Application Related Function Library * * * * *

'========================================
'   Function Name - fnLogin
'   Purpose - This function is used to login to flight reservation application
'========================================
Function fnLogin()

	SystemUtil.Run "C:\Program Files (x86)\HP\QuickTest Professional\samples\flight\app\flight4b.exe"
	Dialog("Login").WinEdit("AgenName").Set "anish"
	Dialog("Login").WinEdit("Password").Set "mercury"
	Dialog("Login").WinButton("OK").Click

End Function

'========================================
'   Function Name - fnInsertOrder
'   Purpose - This function inserts a new order in flight reservation application
'========================================
Function fnInsertOrder()

	Set WshShell = CreateObject("WScript.Shell")
	WshShell.SendKeys "%(fn)" 'Press Alt F+N to open a new order screen
	Window("Flight Reservation").ActiveX("DateOfFlight").Type "010114"
	Window("Flight Reservation").WinComboBox("FlyFrom").Select "Paris"
	Window("Flight Reservation").WinComboBox("FlyTo").Select "Sydney"
	Window("Flight Reservation").WinButton("Flights").Click
	'Select any Flight
	Window("Flight Reservation").Dialog("FlightsTable").WinButton("OK").Click
	'Provide Name and Insert Order
	Window("Flight Reservation").WinEdit("Name").Set "Anish"
	Window("Flight Reservation").WinButton("InsertOrder").Click

End Function

'========================================
'   Function Name - fnLogout
'   Purpose - This function is used to logout from the flight reservation application
'========================================
Function fnLogout()

	Window("Flight Reservation").Close

End Function

Step 2H: Run the code and make sure that everything runs fine.

Once this step is finished successfully, you will have the script that is made up of separate functions. At this point, you can see that the flow of the test case is defined in the QTP Test Script. (All the functions are being called from the QTP Test Script and therefore the flow of the test cases is available in the QTP test script only)

The next step would be to create a Test Case Flow excel sheet where we will add all the keywords associated with the test case. By doing this, the flow of the test case will be dictated by the test case flow excel sheet. Let’s see how this can be done.

Step 3: Creating a Test Case Flow Excel Sheet and mapping it with the Test Script

In this step, we will create a test case flow excel sheet and then add the keywords that have been identified for the test case. Then we will write code that will read the keywords from the excel sheet call the functions associated with the test cases. You can follow the below mentioned steps to perform the above task.

Step 3A: The first step is to identify the keywords that will be associated with our test case. Looking at the functions that we have come up with in the previous step, we can have the following keywords which we can associate with the script -

• login – To login to the application
• InsOrd – To insert a new order into the application
• logout – To logout from the application

Step 3B: Once the keywords have been identified, the next step is to add the keywords in the excel sheet. Create a new excel sheet and add keywords to it as shown in the below image. Save the excel sheet by giving some appropriate name.

Now we have to write the code that will fetch the keywords from the excel sheet and call the associated function. The code to fetch open the excel sheet and fetch the keywords is the generic code that is independent of the application. This is because even if you have some other application, the only change here would be the name of the test case, the keywords and the description.

No matter what the keywords are, the code to fetch them would remain the same. So, the functions that we would write here would go to a separate function library (framework related function library). This way you would be able to keep the generic and application specific code separate.

Step 3C: Create a new function library where you will store the framework specific code. For this framework, we will name this function library as ‘FrameworkRelatedFunctionLibrary’. Associate this function library with the test script.

Step 3D: You have to now write the function that will read the keywords from the excel sheet. Below is the sample code that shows how this can be done.

'========================================
'   Function Name - fnReadKeywords
'   Purpose - This function reads the keywords that are associated to a given test case
'========================================
Function fnReadKeywords(sTCName)

	'Add a new Sheet into QTP Data Table
	DataTable.AddSheet("dtTCFlow")

	'Import the Excel Sheet into QTP Data Table
	DataTable.ImportSheet sExcelLocation, "TestCaseFlowSheet", "dtTCFlow"

	'Loop through all the rows in the Data Sheet
	iRow = DataTable.GetSheet("dtTCFlow").GetRowCount

	For iR=1 to iRow
			'Set the Current Row in the Data Sheet according to the loop counter
			DataTable.SetCurrentRow iR

			'Capture the Keyword based upon the test case name
			If DataTable("TestCaseName", "dtTCFlow") = sTCName Then
					'Call the executeFlow function that will execute the function associated to the keyword
					 executeFlow DataTable("TestCaseFlow", "dtTCFlow")
			End If
	Next

End Function

The above function opens the excel sheet, loads its contents into QTP Datatable and then reads the keywords that are associated to the given test case. Once it identifies the keyword, it passes the keyword to a different function which then executes the actual function associated with this keyword.

Step 3E: The next step is to map the keywords with the actual flow functions so that whenever a keyword is encountered, the matching function can be executed. We will create a separate function where will define the mapping in a Select Case statement. Since this function is dependent on the application, we will store this function in the application related function library. Below you can see how this function has been implemented for the first test case.

'========================================
'   Function Name - executeFlow
'   Purpose - This function executes the functions that are associated to the given keyword
'========================================
Function executeFlow(flowName)

	'Call the function associated with the keyword
	Select Case flowName
		Case "login"  fnLogin()
		Case "insOrd" fnInsertOrder()
		Case "logout" fnLogout()
	End Select

End Function

Now the final part that is pending is to call the above functions from the test script. If you recall, the main test script currently contains the flow of the test case. But now, since the flow has been defined in the test case flow excel sheet, we can remove the previous function calls from the main test script.

We can now just call the fnReadKeywords() function from the main script. Once the function has been called it will do its job and execute all the functions that are associated with the keyword.

Step 3F: Open the main QTP Test Script. Delete the function calls that are written there and write the new code that will call the fnReadKeywords() function and pass the test case name as the parameter. The code for that will look similar to the one shown below.

sTestCaseName = Environment.Value("TestName")
fnReadKeywords sTestCaseName

Step 3G: Execute the test case and see if it is running fine.

Once you verify that the test case is running fine, you will have with you the working model of a basic Keyword Driven Framework where the keywords are mapped at function level. Now you can easily add more test cases to this framework by following the steps mentioned above.

The entire framework together with the function library and flow for all the 3 test cases is available in the sample framework. You can download this framework (link available near the bottom of the article) and play around with the code.

Improvements in the Framework

As mentioned in the beginning of the article, this is a very basic framework that will just contain the basic things to help you understand the concepts easily. You can try to improve this framework by adding more features to it. This would make the framework more robust and easy to use and maintain. This would also work as a practice exercise for you and would help you learn more stuff.

Please note that these changes or improvements are not available in the attached framework. This is just a practice exercise which you can try from your end.

Improvement 1) Currently, the test case flow just contains the TestCaseName, Keywords and Description only. You can try to add an additional Column where you can store the result as ‘Pass’ or ‘Fail’ for each keyword. You would also need to write some code which after executing every function, will update this column as ‘Pass’ or ‘Fail’. This will help you keep a track of the results easily.

Improvement 2) You can add one more additional column which will tell QTP whether the particular flow has to be executed or not. The column can have values as ‘Yes’ or ‘No’. Once QTP encounters a keyword, it will first check this column and then execute the function associated with the keyword only when the column contains the value ‘Yes’.

After implementing the above 2 enhancement points, the test case flow excel sheet would look something like this.

Improvement 3) You would also have observed that the data is hard-coded with the flow. Because of this, if you want to run the flow for multiple data, you would need to change the data values before each run. To avoid this, you can try to separate the data from the flow by adding it to a separate excel sheet. This way you would be able to change the data without touching the flow and you can also re-run the same flow multiple times by using a loop.

Try out these changes and let me know if you face any issues in-between. If you have any points to add here, or if you have any other improvement which can be added in this framework, please let us know about it using the comments section.

Visit QTP Frameworks Main Page for more articles on QTP Frameworks. You can also visit our QTP Tutorials page for more QTP Tutorials.

In the previous two articles we saw how to create a Keyword Driven Framework where the keywords are mapped at Operation Level. In this article, we will cover a different type of Keyword Driven Framework – the one where the keywords are mapped at Functional Level.

Keyword Driven Framework mapped at Functional Level is the most commonly used Keyword Driven Framework type. How its actually implemented may vary from project to project. But the basic premise always remains the same – “define keywords and assign them to actions or functions”.

The important point that should be noted in this framework is that the keywords are mapped to a function which will contain more than one line of code. For example, you can have a keyword called ‘Login’ that in turn can be mapped to function called fnLogin. Now, this function will contain the few lines of code that will open the application, enter user name and password and then click on Submit button.

This is different from the Keyword Driven Framework implementation mapped at Operational Level, where the keyword is mapped to an action performed at object level. (For more details about the basics of the Keyword Driven Framework, refer – Basics of Keyword Driven Framework)

Topics that will be covered in this article

1) The components that are commonly used with this framework.

2) Flow of the test cases in this framework.

Let us see each of these points one by one.

Common Components used in Keyword Driven Framework mapped at Functional Level

Following are the components that are commonly used with this framework -

1) Test Scripts or Driver Script: As mentioned in the beginning of this article, in this type of framework all the keywords are associated with some functions. So naturally, the entire test case flow would be composed of multiple functions.

For example, consider a test case where the you have to login to Gmail, send an email and then you have to Logout from Gmail. Looking at the test case, you can easily figure out that the test case can be divided into 3 functions -

• fnGmail_Login
• fnGmail_SendEmail
• fnGmail_Logout

Normally what we do is – create the functions and then save them in the function library.Then we will create a test script where we will call all these functions one after the other. This is what you do in functional decomposition framework also.

But in the keyword driven framework, the keywords, and hence the flow of the test case are actually specified in the excel sheets (refer below image for example). Now, since the flow of the test case is mentioned in excel sheets, the actual test script will not store the test case flow. Hence the test script will not be used the way we do it in other framework types.

So in this case, the test script would be used as a driver script whose sole purpose would be to pass the control on to the function library.

2) Object Repository: As is the case with all the QTP Framework Types, you can use the Object Repository to store the properties of the objects and then call the same in the test scripts. You can also use the Descriptive Programming approach if you wish to skip using the Object Repository. As part of this framework creation, we will be using the Object Repository to store the object properties.

3) Function Library: In the Keyword Driven Framework, the operations of the function library can be broadly classified into the following two types -

• a) Application Related Flow: This is the most common purpose for which the function library is used for in all the framework types. Application flow means that the function library will contain functions that will depict the flow of the test cases. For example, the function library may contain functions such as Login and Logout which are actually a part of the application under test.
• b) Framework Related Flow: This part of the function library deals with the functions that are not directly related to the application as such. These are the functions which are related to the framework. For example, functions such as read keyword from excel. These types of functions are application independent and can be used at all the places where this framework is implemented.

NOTE: If you are going to implement your Keyword Driven Framework for different applications, you may want to create two separate function libraries for application related flow and framework related flow. This will help you implement the framework for different applications in a smooth manner.

4) Excel Sheets to Store Data: You can use excel sheets to store the data and then use it in your test scripts. You can choose any format for the data sheets as per your requirement. In order to keep things simple, we will be hard-coding the data in the test scripts. Hence we will not be using any data sheets for this framework implementation.

5) Excel Sheets to Store Keywords: In this framework, all the keywords (and hence the flow) associated to the test cases will be stored in excel sheets. The way in which the keywords are added in the excel sheets may differ from project to project. Also, together with the keywords, you can add additional details in the excel sheets which would make the flow more readable. For example, you can -

• a) Add description along with the Keywords: This would make the test case flow more readable.
• b) Add a Result column together with the Keywords: You can add a Result column next to the Keywords and then you can write a function which would update each keyword as pass or fail when the test script is run. So if a test run fails, you can easily figure out till which point the test case has run and at which place it has failed.
• c) Add an execute Column along with the Keywords: If you have Keywords independent of each other, you can add an Execute column along with the Keywords. You can have values as Yes and No in the execute column. You can then write a function which will first check the Execute column and then will execute only those keywords where the value is set as Yes.

The below figure depicts how the excel sheet would look like.

As part of this framework, we will be adding only the keywords and the description about them. But you can try the remaining concepts on your own and see how it goes.

Flow of the Test Scripts in this Framework

In this type of Keyword Driven Framework, the flow of the test scripts will be as follows -

1) The execution of the test cases would start from the QTP Test Script. In this framework, we will create a separate test script for each test case that needs to be automated.

2) The test script will give a call to the function library which contains the code to read the excel sheets containing the keywords. (There will be 2 separate function libraries in the framework. One which handles the framework flow and the other which handles the application flow)

3) The function will read the excel sheet and depending upon the keyword encountered, it will give a call to the function from the ‘application related’ function library.

4) This function would perform the required actions on the application and once done, it would return the control back to the calling function.

The below image depicts the above mentioned flow.

This was the basic information of Keyword Driven Framework mapped at Functional Level. In the next article, we will cover, in detail, on how to create this framework from scratch and write test cases in this framework.

What are your thoughts about this article? You can let us know your response using the comments section.

Visit QTP Frameworks Main Page for more articles on QTP Frameworks. You can also visit our QTP Tutorials page for more QTP Tutorials.

In the previous article on Keyword Driven Framework mapped at Operation Level, we covered the basic features of the framework that we would be creating here. The article contained information about the components that can be used in this framework as well as the general flow of the test cases. In this article, we will actually implement all this and come up with a basic keyword driven framework.

What we would be doing in this article

1) In this article, we will create the keyword driven framework with 3 test cases. All these 3 test cases will be based on Mercury Flight Reservation application (windows based application).

2) The flow of the test cases will be written in the excel sheets. The data for the test cases will also be provided with the flow only.

3) A function library will be created which will contain the code to read the lines from excel and convert in into QTP recognizable format.

4) Towards the end of the article, we will list out few enhancements/improvements which you can try to implement in the framework on your own. This will really help you practice the concepts and get a good hold on the framework.

Identifying the Test Cases for this Framework

Before beginning with the framework creation part, the first step would be to identify the test cases that you want to automate. For this article, we will be working on the following 3 test cases.

1) TC_01_CreateOrder: For this test case, we will write the script that will login to Mercury Flight Reservation system and then create a new flight reservation.

2) TC_02_ModifyOrder: In this test case, the script will log in to the application, open an existing order and then modify the order.

3) TC_03_DeleteOrder: Here, the script will again log in to the application, open an existing order and then delete the order.

Step by Step method to create the First Test Case

As always, the hardest part is to begin with the first step. Once that is done, the remaining portions become relatively easier to do. So in this article, we will describe how to create the first test case in detail. Once you are comfortable writing the first test case, the remaining ones will be fairly easy to tackle.

Writing test cases in this framework can be divided into 3 main parts:

Step 1) Writing the test case flow in excel sheet.

Step 2) Writing functions in the function library that will read the excel sheet.

Step 3) Combining Steps 1 and 2 to run the test case.

Let’s see each of these steps one by one.

Step 1-A: The first step would be to define the format of the excel sheet that will be used to store the flow of the test cases. You would need to create a format and stick with it for all the test cases.

To create the excel sheet format that we will be using here, open an excel sheet and add the values as shown in the below figure.

Step 1-B: Let’s now have a look at this format in detail and see what different columns mean and what kind of data will go in each of these columns.

Parent [Column A] – This column will contain the hierarchy of all the objects until the actual control on which you want to perform some operation. For example, consider the below statement -

Browser(“B”).Page(“P”).Frame(“F”).WebEdit(“W”).Set “some value”

Here, WebEdit(“W”) is the object on which you will perform the operation. So the hierarchy before it would be: Browser – Page – Frame. So Column A will contain the value Browser,Page,Frame

Please note that Column A will only list the Object names and not there properties. Also, the object names are separated by the delimiter comma (,)

PProperty [Column B] – This column will contain the properties of the objects that were added in Column A. The properties will also be separated by comma (,). Also, the property of an object is usually a name value pair. The name and value will be written as is it done in case of descriptive programming. So as per the above example, column B can have text like – title:=B,title:=P,name:=F

Control [Column C] – Column C will contain the name of the control on which you want to perform the operation. In this example, the control is WebEdit(“W”) on which you want to perform the Set operation. So Column C will contain the value WebEdit. Since there will always be only one object on which you will need to perform some operation, so there would be no hierarchy of objects in this column.

CProperty [Column D] – Column D will contain the property that is associated with the object in Column C. Here let use assume that the WebEdit has ‘W’ as its name. So, the value in Column D would be name:=W

Action [Column E] – This column stores the name of the action that needs to be performed on the object. This action or operation will be the keyword that will be mapped to some appropriate operation in the function library. In our example, the action that needs to be performed is Set. So we can use a keyword SetValue to denote this action. So column E will contain the value SetValue

Data [Column F] – In this column, you will be providing the data that goes with the action. For example, for Set action, we will need to provide the data that will be entered in that particular field. In this case, the value that will go to Column F is ‘some value’ (without ‘ ‘).

Also, there will be certain cases where there would be no data requirement. For example, click operation on a button. In this case, you just need to click on the button, there is no data that needs to entered anywhere. So in such cases Column F will be empty.

The below image shows how the flow will look in excel sheet for the sample sheet covered here.

NOTE 1: There would be certain cases where you would need to perform operation on the parent object only. For example, you may want to close the parent window. Here, this close operation will be performed on the parent object. So in such cases, columns C and D will be empty. Only Columns A and B will be filled in with values to identify the parent object.

NOTE 2: There will also be certain cases where the operation would not be performed on any object. For example – SystemUtil.Run statement. This statement doesn’t work on any object, neither parent nor child. So in such cases, Columns A, B, C and D will be empty. Only column E will have some value which will depict the operation that needs to be performed.

The below image will make these two points more clear.

Step 1-C: Since you have understood the structure of the test case flow excel sheet, we can now start writing the flow of the test case in the excel sheet. You can follow the below mentioned steps to start with the process.

1) Open QTP. Since we will be working on a windows based application, you can deselect the Web Add-in from Add-in Manager at start-up. (If you need more information about QTP Add-in manager, you can check how to enable/disable Add-in Manager and  how to install/uninstall other add-ins).

2) Once QTP is opened, open the ‘Mercury flight reservation application’, so that the login screen of the application is displayed.

3) Now whatever actions we have to perform in the application, we have to capture it in the excel sheet. As an example, we will just work on the login portion of the application where we will enter Agent Name, the Password and then we will click on OK button. Once this is done, we will close the main window of the application.

4) To capture the object properties, we will use the Object Spy. Open object spy and click on the Agent Name field. Once you spy on the Agent Name field, you would note that the hierarchy in the Object Spy window consists of 2 elements – Dialog and WinEdit (image shown below). And from the structure of the excel sheet that we mentioned above, it can easily be made out that the object Dialog with its properties would go in columns A and B, and the object WinEdit and its properties will go in columns C and D. The action that we would need to perform here is Set.

5) Have a look at the properties of both the controls and select the ones that you think will uniquely identify both the objects. Add the objects and the properties in the excel sheet in the 2nd row (just below the header).

NOTE 3: If you are not comfortable with this process of identifying the properties using Object Spy, you can follow an alternate method where you can first record the scenario in QTP. Then you can go to local Object Repository and select the values that have been used by QTP. Once you start working with this approach, you will be able to work real quickly with the Object Spy because you would get an idea about the properties that usually go with different types of objects.

6) Once you have added the values for Agent Name field in the excel sheet, you can follow the same process to add the values for entering values for password field and OK button. Once you are done with all these steps, you would have an excel sheet that would look similar to the image below (the properties of the objects may change based upon what values you have selected to use).

You would have noted that we have added the word End in the 6th row. This End word indicates to QTP that the test case has ended here. So when QTP encounters this keyword, it will stop processing this test case. We have also added Run command in Row 2. This command will instruct QTP to open the flight reservation application.

Since we have written the flow of the login portion in the excel sheet, we can leave it at this step for the time being and start concentrating on the next part which is – writing code or functions in the function library that will read the excel and convert it into QTP readable format. The idea here is that we will create the necessary functions and then run the script for the 5-6 lines you have written in the excel sheet. Once you are able to run the excel statements from QTP, you can be sure that the logic is working fine. Then you can just add on the steps in the excel sheet and run everything from QTP.


Step 2) Writing functions in the function library that will read the excel sheet. Now there are multiple categories of functions that you will need to write here. Let’s see what are these different categories of functions -

a) Category 1: Function(s) that will be used to open or connect to the excel sheet.

b) Category 2: Function(s) that read each line in the excel and convert it into QTP readable format.

c) Category 3: Function(s) that do some action on the application. Like click on button, set value in some text field etc.

d) Category 4: Function(s) that will call the Category 3 functions based upon the keyword in the excel sheet.



Before writing the functions, make sure that you create a function library and associate it with your QTP Test Case. Once this is done, you can start writing these functions one by one. Below we have covered few of these functions which will help you understand the logic.

1) Function that reads the excel sheet and loads the cell values into Global Variables. We are using global variables because the variables are being used in multiple functions. (To read more about global variables, you can read – Different ways to define Global Variables in QTP)

'========================================
'	Function Name - fnReadExcel
'	Purpose - This function loads the excel sheet into QTP data table and stores the cell values in Global Variables
'========================================
Function fnReadExcel(sSheetName)

	 	'Add the Data Sheet into QTP Data Table
		DataTable.AddSheet("dtSheet")

		'Import the Excel Sheet into QTP Data Table
		DataTable.ImportSheet sExcelLocation, sSheetName, "dtSheet"

		'Loop through all the rows in the Data Sheet
		iRow = DataTable.GetSheet("dtSheet").GetRowCount

		For iR = 1 to iRow
				'Set the Current Row in the Data Sheet according to the loop counter
				DataTable.SetCurrentRow iR

				'Capture all the cell values in different variables
				sParent = DataTable("Parent", "dtSheet")
				sParentProp = DataTable("PProperty", "dtSheet")
				sControl = DataTable("Control", "dtSheet")
				sControlProp = DataTable("CProperty", "dtSheet")
				sAction = DataTable("Action", "dtSheet")
				sDataValue = DataTable("Data", "dtSheet")

				'Call the function that will convert the excel data into QTP readable format
				If sParent = "End" Then
						Exit For
				ElseIf sParent <> "" Then
						fnIdentifyParentHierarchy()
				Else
						'The action is independent of the all the controls (refer NOTE  2 from the article)
						fnAction()
				End If

		Next

End Function
'============= End Function ===============

2) The below function converts values from columns A and B of the excel sheet into QTP readable format.

'========================================
'	Function Name - fnIdentifyParentHierarchy
'	Purpose - This function converts the values in cells A and B into QTP readable format
'========================================
Function fnIdentifyParentHierarchy()

	 	'Split Parent Property so that multiple objects casn be resolved
		arrParentProp = Split(sParentProp, ",")

		'Resolve the hierarchy of all the objects that are parent to the actual control
		Select Case sParent

				Case "Dialog"
						Set obj_hierarchy = Dialog(arrParentProp(0))

				Case "Window"
						Set obj_hierarchy = Window(arrParentProp(0))

		End Select

		'Call the function that will resolve the Control Object
		fnIdentifyControl()

End Function
'============= End Function ===============

3) This function converts data from cell C and D in QTP readable format. Later, it combines values in Cells A, B, C and D to form one complete object on which the action will be performed.

'========================================
'	Function Name - fnIdentifyControl
'	Purpose - This function converts the values in cells C and D into QTP readable format and then combines values from Cells A, B, C and D to come up with a single object
'========================================
Function fnIdentifyControl()

		'Split the Control Property
		If sControl <> "" Then
				arrControlProp = Split(sControlProp, ":=")

				'Resolve the Control object to obtain the complete heirarchy on which the action can be performed
				Set child_object = Description.Create()
				child_object("micclass").value = sControl
				child_object(arrControlProp(0)).value = arrControlProp(1)

				'Create the object on which the action will be performed
				Set control_object = obj_hierarchy.ChildObjects(child_object)
		Else
				'Control Object is the parent hierarchy on which the action will be performed (refer NOTE 1 from the article)
				Set control_object = obj_hierarchy
		End If

		'Call the function that will perform the necessary action on the object
		fnAction()

End Function
'============= End Function ===============

4) The below function performs Actions or Operations on the object which is retrieved from the previous function.

'========================================
'	Function Name - fnAction
'	Purpose - This function performs action on the object based upon the defined keyword
'========================================
Function fnAction()

		'Perform Action on the control_object based upon the keyword defined in the excel sheet
		Select Case sAction

				Case "SetValue"
						control_object(0).Set sDataValue

				Case "Click"
						control_object(0).Click

				Case "WindowClose"
						control_object.Close

				Case "Run"
						SystemUtil.Run sDataValue

		End Select
End Function
'============= End Function ===============

Please don’t worry much if you don’t understand the code and functions at this point in time. Once you have a look at the entire framework, you will get a fairly good idea about the functions and how they interact with each other. For ease of understanding, you can check the below image which shows the low level flow of a test case as per this framework.

The good part of this framework and the function library is that you would need to work more on the functions and the code in the initial part only (when you are beginning to develop the framework). As and when you add new code in the function library, you will be able to reuse it for similar type of objects and hence the time taken to write the later test cases will be greatly reduced.

As an example, you can see that the functions SetValue, Click etc are already written in the function library. Now, if you want to use these functions for any other text box, button or link, you would just need to call the keyword in the excel sheet. The more you work on this framework, there would come a time when you would mostly need to write the flow in the excel sheet only. Most of the keywords would already have been covered in the function library.

Once we have written the basic functions for running the script from excel sheets, we need to combine everything together and run the code to see if it works.


Step 3) Combining Steps 1 and 2 to run the test case. To combine everything together, you need to create a proper framework with the folder structure, save the function library and the excel sheet in appropriate locations. Now you should create a QTP Test Case (which will act as a driver script in this case). Associate the function library with the test case and call appropriate functions that will run the test case. (You can check the folder structure and other details from the sample framework attached at the end of this article)

In this example, we have called the function fnExecuteTestCase() in the Driver Script and passed the test case name as a parameter to this function. This function is nothing but a wrapper function which gives a call to fnReadExcel() function. Since the test case name and sheet names are same, the function fnReadExcel will call the appropriate sheet and execute the flow provided in the excel sheet.

'Code in Driver Script

'Execute --> TC_01_CreateOrder
fnExecuteTestCase("TC_01_CreateOrder")

Run the test case to see if the code is running correctly. Once you have verified that the code is running fine, you can then keep on adding the flow in the excel sheet and add corresponding keywords in the function library. Just make sure that whenever you encounter a new keyword, you have to add it in the excel sheet and write corresponding action in the function library. This way you would be able to create all the 3 test cases easily without any issues.

The entire sample framework together with the function library and flow for all the 3 test cases is available in the sample framework. You can download this framework (link available near the bottom of the article) and play around with the code.

Can you Improve this Keyword Driven Framework?

Have you read this article and tried to work on the sample keyword driven framework attached here? Have you understood all the functions and the entire flow of test cases in this framework? If yes, then you can try to improve this framework by adding more features to it. This would make the framework more robust and easy to use and maintain. This would also work as a practice exercise for you and would help you learn more stuff.

Since this is a basic framework created to just help you understand the basics, there are many things which are not covered as part of this framework. I would list down the points here and you can try to modify the framework by incorporating these changes. Please note that these changes or improvements are not available in the attached framework. This is just a practice exercise which you can try from your end.

Improvement 1) You would have noticed here that the test case flow in excel sheets is not modularized. For example, all the 3 test cases contain the flow of the login part (which means that login code is repeated in all the 3 test cases). You can try to modularize this flow where instead of having the complete test case flow in one excel sheet, you can try adding just a module, like login or create order in one excel sheet. This way you would be able to reuse many common flows.

Improvement 2) You would also have observed that the data is hard-coded with the flow. Because of this, if you want to run the flow for multiple data, you would need to change the data values before each run. To avoid this, you can try to separate the data from the flow by adding it to a separate excel sheet. This way you would be able to change the data without touching the flow and you can also re-run the same flow multiple times by using a loop.

Try out these changes and let me know if you face any issues in-between. If you have any points to add here, or if you have any other improvement which can be added in this framework, please let us know about it using the comments section.

Visit QTP Frameworks Main Page for more articles on QTP Frameworks. You can also visit our QTP Tutorials page for more QTP Tutorials.