What is

Data Driven Automation

Framework?

As the name
suggests, Data Driven Testing Framework is a
framework which
is driven by test data, which means that test data is
the important
factor here. The basic expectation with this kind
of test
automation framework is that your test scripts
should be built
in such a way that it should work for different
sets of data
without any changes to the test script.
Consider a
scenario where you have a large number of user
credentials for an
application. You need to login to the application with
each of these
credentials to find out which of the user credentials
are working properly and which are not. In order to complete this task, you can create a script in QTP which
would read each of the user credentials and try to login to the application and at the end would report the
results.

What is the basic approach used to create a Data Driven Framework?

If you would have noticed in the previous articles on Linear and Modular Automation Frameworks, the test
scripts were written in a way where the test data was hard-coded with the test script. i.e. the data and the
script were together as a single unit. Now try to superimpose this approach on the scenario (checking
multiple login credentials) we discussed above. If you were to use this approach on the above scenario, you
would need to change the test data in the script after each run which is not such a good idea because the
basic premise of automation is you have to aim for least amount of manual intervention
possible.
There is one more important point to be considered here. You would have noticed that QTP experts are
involved in creating the test scripts and many a times manual testing team is given the job of running the
scripts for regression and other purposes. Mostly they would not be having much idea about how to use QTP
and hence it will be difficult for them to go through the code and change the test data. This process might
leads to some errors also if things are not done properly. Because of this, code + data together as a one
unit doesnt work out very well.
So now lets come back to the point. What is the approach to create a data driven framework? In
simple terms, all you have to do is to just separate your code and data. And your Data Driven
Framework is ready. You would have to store your data in some external files (such as text files, excel,
database etc) and figure out a way to read the data from this external source and pass it to your application
through some variables. Thats all..

Components of Data Driven Framework in QTP

In order to create a Data Driven Framework in QTP, you need to have the following components available.
1) Test Script & Object Repository: The Test Script and the Object Repository (if you are not using
complete Descriptive Programming) reads the data from the external sheet and then uses it on the
application under test.
2) External Data Source: There will be an external data source that will contain all the test data that you
need to run your test script.
Figure below shows the pictorial representation of the data driven framework in QTP.

What are the different Data Sources that can be used in QTP?
QTP supports a wide variety of Data Sources from where you can extract data for your test scripts. Some of
these are 1) Microsoft Excel
2) Text files
3) XML files
4) Databases like SQL, Oracle etc
5) and many more
Although there are many data sources that you can use with the QTP test scripts, the data
source that is used almost all the times is Microsoft Excel. In most of the applications that you would
be automating, you would be taking data from excel only.

However there are many cases where you would be using some different data sources also. For example, if
you are working on an end to end billing application, many a times the product and billing information are
stored in XMLs. So in these type of scenarios, your primary data source will be xml.
There would also be many cases where you would need to use more than one data source. For
example, in the above scenario, xmls will be your primary data source but you can use excel sheet also to
save login credentials, URLs etc of the application. So excel in this case would be the secondary data source.

Different ways to extract data from Microsoft Excel in QTP

QTP (and VBScript) provides you with 3 ways using which you can extract data from an excel sheet. These 3
methods are Method 1 Using QTP And Data Table. Here, you can save
all your data in QTP data table and write the script which will
extract data from the data table.
Method 2 Using QTP, Data Table and MS Excel. In this
method, the QTP first copies the data from the excel sheet into
QTP data table. It then uses the QTP in-built methods to read
data from the data table.
Method 3 Using QTP and MS Excel. Here the data is stored
in MS Excel and QTP uses EXCEL COM methods to read the data
directly from the excel sheet only.

The approach used in this article

In this article, the script that we will create will use the first
method shown above. That is, we will create a test case and
save the data in the QTP Data Table. Then we will write the script
that will read the data from the data table and use it in the
application (The remaining two methods which use MS Excel will
be covered in the next part of this article).

Sample Script for Data Driven Framework

Sample Script: In this article, we will create a script that will
check the Login functionality of windows based Mercury Flight
Reservation application. Instead of hard-coding the data in the code, we will store the data in QTP Data Table
and write code in QTP to take data from the data table itself. Also, we will provide multiple rows of data in the
data table and instruct QTP to run the test script for all the rows in the data table. For example, if the data
table contains 10 rows of data, the script will also execute 10 times, that is, one time for each row.
Lets see how to implement this in a step by step manner.
Step 1: Create a New Test Case in QTP and Save it at any desired location.
Step 2: In the test case, verify if Data Table is visible at the left bottom of the screen. If not, select View ->
Data Table from the QTP menu. Data Table should now be visible at the left bottom of the screen (Refer image
below).
Step 3: Click on the Data Table to open it. This would open
the empty data table as shown in the below figure.

Step 4: Now, the next step is to fill in the data in the data sheet. We will do this by setting up the header for
the columns first. Notice that the column headers are displayed as A, B, C, D and so on. To change a column
header, double click on that column header. QTP will provide a popup where you need to provide the new
value for the header. In this case, we want to change the value A to something meaningful like UserName.
So double-click on A and a new popup box will appear as shown below.
Step 5: Enter UserName in the text field in the popup message and click on Ok button. Once you do that you
would notice that the name of the column will get changed from A to UserName. Refer the image below.
Step 6: Similarly change the column header B to Password.

Step 7: Now is the

time to enter some
data in the
datatable. Enter
some valid user
credentials in the
first row. Dont
forget to save the
test case after
changing the data.
Figure below shows
the snapshot of the
datatable after
adding single row of data.
Please note that there are two sheets available in the datatable Global
and Action1, and we are adding the data in the Global sheet.
Step 8: Once we have the data ready, its time to write the code that will
fetch the data from the datatable. To fetch the value from the
DataTable, we will use DataTable.Value command. If you want to
fetch the username from Global sheet, the command will be var =
DataTable.Value(UserName, Global). When you run this
statement, value anish will be stored in variable var.
Lets see the entire script that will a) Open Flight Reservation Login screen.
b) Enter user id and password.
c) If Login is successful, QTP will close the application.
d) If Login is unsuccessful, then also QTP will close the application.
In this example, we will use descriptive programming approach without adding any objects to
the Object Repository. To learn more about descriptive programming approach in QTP, you can
read Descriptive Programming in QTP Part1 and Part2.
'Open Flight Reservation Application
SystemUtil.Run "C:\Program Files (x86)\HP\QuickTest Professional\samples\flight\app\flight4a.exe"
'Enter UserId and Password
Dialog("text:=Login").WinEdit("attached text:=Agent Name:").Set DataTable.Value("UserName", "Global")
Dialog("text:=Login").WinEdit("attached text:=Password:").Set DataTable.Value("Password", "Global")
'Click on Ok button
Dialog("text:=Login").WinButton("text:=OK").Click
'Check if Login is Successful or Not
'Check if error message is displayed
If Dialog("text:=Login").Dialog("text:=Flight Reservations").Exist(4) Then
'Click on Ok button to close the dialog
Dialog("text:=Login").Dialog("text:=Flight Reservations").WinButton("text:=OK").Click
'Click on Cancel to Close the Login Screen
Dialog("text:=Login").WinButton("text:=Cancel").Click
Reporter.ReportEvent micFail, "Login Unsuccessful", ""
'Login is successful. close the application
Reporter.ReportEvent micPass, "Login Successful", ""
Window("text:=Flight Reservation").Close()
Step 9: Now we have run the code with a single row of data. Let us now add more rows to the data table to
run the code for all these data. Refer the below screenshot where we have added total 5 rows in the data
table.

Step 10: To run

the test case for
all the rows in
the datatable,
you can use one
of the following
2 methods Method 1: In this method, we dont make any
change in the code, but change the QTP settings to
run the test cases as many number of times as the
number of rows in the DataTable. To change this
setting, select File -> Settings -> Run (from the left
hand side pane) and select the Radio button Run
on all rows. This would instruct QTP to run the script for
all the rows in the DataTable. Refer the below screenshot
for the setting.
If you now run the above code, you would see that the script is run 5 times automatically with different set of
data during each run.
Refer the below screenshot for the test result. Here you can note that the iterations 2 and 3 have failed
because of invalid login credentials.
By the way, if you are not aware of the login
credentials for the flight application, it is: Login
Name any name 4 or more characters long and
password mercury
Method 2: In this method, you dont change to
setting in QTP to Run on all rows. Instead
you modify the code so that it takes the data
from each row in the datatable using a loop.
For this method, again select File -> Settings -> Run
and select the radio button Run one iteration
only. Now we have to add a loop to our code so that
it can run on all the 5 rows of data. Check the
modified code below which will run on all the rows in the DataTable.
iRows = DataTable.GetRowCount
'Loop through all the rows
For iR = 1 to iRows
'Set the current row
DataTable.SetCurrentRow iR
'Open Flight Reservation Application
SystemUtil.Run "C:\Program Files (x86)\HP\QuickTest
Professional\samples\flight\app\flight4a.exe"
'Enter UserId and Password
Dialog("text:=Login").WinEdit("attached text:=Agent Name:").Set
DataTable.Value("UserName", "Global")
Dialog("text:=Login").WinEdit("attached text:=Password:").Set
DataTable.Value("Password", "Global")
'Click on Ok button
Dialog("text:=Login").WinButton("text:=OK").Click
'Check if Login is Successful or Not
'Check if error message is displayed
If Dialog("text:=Login").Dialog("text:=Flight Reservations").Exist(4) Then
'Click on Ok button to close the dialog
Dialog("text:=Login").Dialog("text:=Flight
Reservations").WinButton("text:=OK").Click
'Click on Cancel to Close the Login Screen
Dialog("text:=Login").WinButton("text:=Cancel").Click
Reporter.ReportEvent micFail, "Login Unsuccessful", ""
Else
'Login is successful. close the application
Reporter.ReportEvent micPass, "Login Successful", ""

Wait(1)
Window("text:=Flight Reservation").Close() End If
After you run this code, you will get the same result i.e, for rows 2 and 3 the login will fail. But
did you notice the change in format of result in this case and the previous case?

Advantages and Disadvantages of using DataTable as a Data Source

Advantages

a) The main advantage of this method is that it is very each to script for taking data from
the datatable.
b) Another advantage is that you can use the Run on all rows setting to run the same script
for multiple data without making any changes in the script.

Disadvantages
a) This concept cant be used for complex frameworks where you need to reuse the same
set of data for different test cases
b) This method also doesnt work with modular framework where the test data needs to be
grouped based on the functions rather than test cases.

Identifying Test Cases for this Framework

The first step for creating the framework is to identify the test cases that we will be automating as part of
this framework. Below is the list of the test cases that we will be working on here.
1) TC_01_GmailInbox In this test script, we will log in to GMail and then will find out the number of
unread emails in Inbox.
2) TC_02_GMailLabel In this test case, we will again log in to GMail and then create a new Label in GMail.
3) TC_03_GoogleSearch In this test case, we will open Google home page, then search for a string and
will find out the number of results returned for that particular search.

Identifying the format of the Excel Sheet

After you have identified the test cases, you will need to do some analysis to find out what all data would be
needed for these test cases and then figure out the appropriate data sheet format best suited for these test
cases.
For this article we will be working on the data sheet format where each test case will have its own excel
sheet. Since we have 3 test cases here, we will be using 3 excel sheets all saved in a single excel workbook.
In short 1 excel workbook having 3 sheets.

Identifying how you will fetch data from Excel Sheet

Once you have identified the format of the data sheet, you need to decide on the method that you will use to
fetch data from the excel sheet. The method that we will use as part of this article is Step 1: QTP opens the excel workbook and copies the required data sheet.
Step 2: QTP then pastes the contents of this sheet into QTP Data Table.
Step 3: QTP uses its own functions to read the data from the Data Table.

Once you are done with all these initial things, you can start creating the test scripts.

Step by Step method to Create the First Test Case in the Framework

The relatively tougher part here is to write the first script

or module and then modify it as per your framework.
Once you have created your first script (as per
framework) it becomes very each to write the remaining
modules or test scripts.
This is because most of the important code such as
connecting your test case with the data sheet and
fetching the data would already have been done in the
beginning itself. Once it is done, you only need to call
these functions wherever required.
As an example, we will cover the Log in portion of GMail in detail here. Once you understand the concept,
you can then build the rest of the code easily without any issues.
Step 1: Open QTP, create a new Test Case and save it at any desired location.
Step 2: Since this is the first test case of the framework, you can first write the script with hard-coded data.
Then you run this code to verify that the functionality is working fine. Once you confirm that the functionality
is working fine, you can write the code to that would fetch data from the data sheet.
Step 3: Create an Object Repository and associate it with your test case. Add the required objects and then
write the code that will log in to GMail. The code should look something like this 'Open GMail
SystemUtil.Run "iexplore.exe", "http://www.gmail.com"
'Page Sync
Browser("Gmail").Page("Gmail").Sync
'Login to Gmail
Browser("Gmail").Page("Gmail").WebEdit("UserName").Set "valid gmail login id"
Browser("Gmail").Page("Gmail").WebEdit("Password").Set "valid gmail password"
Browser("Gmail").Page("Gmail").WebButton("SignIn").Click
'Page Sync
Browser("Inbox").Page("Inbox").Sync
Run the above code and see if it is working fine.
Step 4: Now you have to create the data sheet for this test case. To do this, create a new excel workbook
and save it as DataSheet.xls inside your framework folder. (you can give any meaningful name to the
Workbook)
Step 5: Open the Workbook. You would find that there are 3 sheets in the Workbook Sheet1, Sheet2 and
Sheet3. You need to provide some meaningful name to the sheet that you are going to use. As a best
practice, you can keep the same name for the test case and the excel sheet.
Since we are writing code for TC_01_GmailInbox, you can rename Sheet1 as TC_01_GmailInbox
as shown below.

Step 6: The next step is to add data to

TC_01_GmailInbox sheet. From the above code you can notice that
we have hard-coded 3 parameters in the script. These are GMail
URL, User ID and Password. We would now add all these parameters
in the data sheet. Add the data in the data sheet as shown in the below image.

Step 7: Now you have to write the code that

fetch data from the data sheet and then put it in
application. Check the below function that copies
excel data into QTP Data Table and then returns
value based on the column name.

will
the
the
the

Function fnGetDataTableValue(strColumnName)
'Add a data sheet in the QTP Data Table
DataTable.AddSheet("dtDataSheet")
'Import the Excel Sheet into QTP Data Table
DataTable.ImportSheet "D:\DataSheet.xls", sTestCaseName, "dtDataSheet"
'Find and return the value based on the column name
DataTable.SetCurrentRow 1
fnGetDataTableValue = DataTable.Value(strColumnName, "dtDataSheet")
'Remove Reference
DataTable.DeleteSheet("dtDataSheet")
End Function

Step 8: Since this is a reusable function that will be re-used

across all the 3 test cases, you should add this function in an external function library and then
associate that function library to your test case. (For more info on this, read the 4th method in how to
associate function library to a QTP script).
Step 9: Once you have associated the function library to your script, you can modify the main script
so that now it takes data from the data sheet. The modified
code is shown below 'Get the Test Case Name that will be used in fnGetDataTableValue function
sTestCaseName = Environment.Value("TestName")
'Open GMail
sUrl = fnGetDataTableValue("URL")
SystemUtil.Run "iexplore.exe", sUrl
'Page Sync
Browser("Gmail").Page("Gmail").Sync
'Login to Gmail
sUserName = fnGetDataTableValue("UserID")
Browser("Gmail").Page("Gmail").WebEdit("UserName").Set sUserName
sPassword = fnGetDataTableValue("Password")
Browser("Gmail").Page("Gmail").WebEdit("Password").Set sPassword
Browser("Gmail").Page("Gmail").WebButton("SignIn").Click
'Page Sync
Browser("Inbox").Page("Inbox").Sync
The above code is the most basic way you can implement this concept. There is still room for a lot of
improvement in the code. If you notice the code, you would see that we are first capturing the value from
the Data Table in a variable and then we are then using it with the Set function (Lines 11-12 & Lines 13-14).
This is not a good programming practice because we are using 2 lines of code to perform a small action.
So to make the code bit more readable, you can create a custom Set function, that will first fetch the value
from the Data Table and then it will put it in the application. This can be achieved by using the concept of
function overriding in QTP. The custom Set function would look something like this.

Function fnSetValue(objControl, strColumnName)

Dim sReqdValue
'Get value from DataTable
sReqdValue = fnGetDataTableValue(strColumnName)
objControl.Set sReqdValue
End Function
Since this function is also a reusable function, you have to add it to the function library and bind it to the
WebEdit control. Your final code (for the login portion of the script) should look something like
this.
'Get the Test Case Name that will be used in fnGetDataTableValue function
sTestCaseName = Environment.Value("TestName")
'Open GMail
sUrl = fnGetDataTableValue("URL")
SystemUtil.Run "iexplore.exe", sUrl
'Page Sync
Browser("Gmail").Page("Gmail").Sync
'Login to Gmail
Browser("Gmail").Page("Gmail").WebEdit("UserName").fnSetValue "UserID"
Browser("Gmail").Page("Gmail").WebEdit("Password").fnSetValue "Password"
Browser("Gmail").Page("Gmail").WebButton("SignIn").Click
'Page Sync
Browser("Inbox").Page("Inbox").Sync

Step 10: Run the above code and see if it runs without any errors.
Once this is done, you can create the remaining portions of the script in the same way shown above. Since
the code to fetch data from the data table is already implemented, you need to just add required columns in
the excel sheet and use the custom functions in the script to fetch those values.This was all about the basics
of Data Driven Framework approach where you can fetch the data from excel sheet through QTP Data Table.
We have also created the code for all the 3 test cases using this same approach. If you wish, you can
download the entire framework and use it as a reference in case you get stuck anywhere.

In this final part of the articles on QTP Data Driven Framework, we will cover the 3rd method of storing and
retrieving data, where the data would be saved in excel sheet and would be directly fetched from
excel sheet only (as opposed to the previous method where the data was first copied from excel sheet to
QTP Data Table and then fetched from the data table).
This article will be created on the same lines as the previous article on Data Driven Framework. So lets
directly start with what all will be covered in this article.

In this article we will

1) create 3 Test Scripts that will work on GMail and Google.

2) create a single excel workbook which will have only one excel sheet inside it.
All 3 test cases will be added as 3 different rows in the same excel sheet.

Identifying Test Cases to be automated for this Framework

As part of this article, we will be automating the same set of test cases that we had automated in the
previous article. These test cases are -

1) TC_01_GmailInbox: In this test script, we will login to GMail and then will find out the
number of unread emails in Inbox.
2) TC_02_GMailLabel: Here, we will again login to GMail and then create a new Label.
3) TC_03_GoogleSearch: In this test case, we will open Google home page, then search for
a string and will find out the number of results returned for that particular search.

Identifying the format of Excel Sheet

For the sample framework in this article, we will create an excel workbook and then add only a single sheet to
it. All the test cases will be added as separate rows in the same excel sheet. Since we have 3 test cases, we
will be having 3 rows of data in the excel sheet (without including the header).

Identifying how to fetch data from Excel Sheet

In this framework, the data will be fetched directly from the excel sheet only. That is, we would be writing
code that would open the excel sheet and then fetch the data based on the row and column. This would be
accomplished using Microsoft Excel Object Model.

Once you have identified the test cases, the data sheet format and the method using which you will fetch the
test data, you can start creating your test scripts.

Step by Step method to Create the First Test Case in the Framework
To explain the entire process in a detailed step by step manner, we will take up the Login to GMail portion of
the first test case and then explain it in detail. This would help you become familiar and comfortable with the
process. Once this is done, you can yourself create the remaining test scripts without any issues.
Step 1: Open QTP, create a new Test Case and save it at any desired location.
Step 2: Since this is the first test case of the framework, we will write the script for GMail login and hardcode the data in the script itself. Then we will run the code to verify that the functionality is working fine.
Once we have verified that the functionality is working fine, we can then write the code that will fetch data
from the excel sheet.
Step 3: Create an Object Repository and associate it with your test case. Add the required objects for GMail
login and then write the code. The code should look something like this 'Open GMail
SystemUtil.Run "iexplore.exe", "http://www.gmail.com"
'Page Sync
Browser("Gmail").Page("Gmail").Sync
'Login to Gmail
Browser("Gmail").Page("Gmail").WebEdit("UserName").Set "valid gmail login id"
Browser("Gmail").Page("Gmail").WebEdit("Password").Set "valid gmail password"
Browser("Gmail").Page("Gmail").WebButton("SignIn").Click
'Page Sync
Browser("Inbox").Page("Inbox").Sync
Run the above code and see if it is working fine.
Step 4: Now you have to create the data sheet to replace the hard-coded data with your custom function
that will fetch the data from the excel sheet.
To do so, create a new excel workbook and save it as DataSheet.xls inside your framework folder. (you can
give any meaningful name to the Workbook)
You would notice that the excel workbook already has 3 excel sheets Sheet1, Sheet2 and Sheet3, added to
it. Since we require only one data sheet in the workbook, delete sheets Sheet2 and Sheet3 from the excel
workbook.
Now rename Sheet1 to some meaningful name (say TestData). Your excel workbook will look something like
this.

Step 5: Once you have created the data sheet, the next step will
be to add data to this excel sheet. Add the data in the excel
sheet as shown in the below image. Please note that the
values in Column 1 should be same as the test case
name, so that QTP can pick up the data correctly based
on Test Case name.

Step 6: Now you will need to write the code that will fetch the
data from this excel sheet. The logic for fetching the data goes
like this.
i. QTP opens the excel sheet.
ii. QTP loops through the first column to read the test case name from each cell.
iii. QTP compares the test case name (from the excel) with the current test case name
(which is currently opened in QTP).
iv. Once a match is found on the test case name, QTP the loops horizontally to read the data
from the particular row where the test case name
matched.

Check the below code that will fetch data based on Test
Case name and Column Name.
Function fnGetDataFromExcel(strColumnName)
Dim iReqdCol
fnGetDataFromExcel = "<empty>"
'Open the Excel
Set oExcel = CreateObject("Excel.Application")
Set oWorkbook = oExcel.Workbooks.Open(sExcelPath)
Set oSheet = oExcel.Sheets("TestData")
'Find the total number of rows in the excel
iRows = oSheet.UsedRange.Rows.Count
iCols = oSheet.UsedRange.Columns.Count
'Find the column number from where data needs to be fetched
For iC = 2 to iCols 'Loop started from 2 because the first column is Test Case name
If oSheet.Cells(1, iC).Value = strColumnName Then
iReqdCol = iC
Exit For
End If
Next
'Loop through the rows to find the test case name
For i=2 to iRows 'Loop started from 2 because 1st row is header
If oSheet.Cells(i, 1).Value = sCurrentTestCase Then
fnGetDataFromExcel = oSheet.Cells(i, iReqdCol)
End If
Next
'Close the Excel
oExcel.Quit()
Set oExcel = Nothing
Set oWorkbook = Nothing
Set oSheet = Nothing
End Function
Step 7: As done in the previous article, you can create a custom set function that will first fetch the value
from the excel sheet and then it will populate the fetched value in required text boxes in the application. The
code for the custom function is shown below.

Function fnSetValue(objControl, strColumnName)

Dim sReqdValue
'Get value from Excel Sheet
sReqdValue =
fnGetDataFromExcel(strColumnName)
objControl.Set sReqdValue
End Function
Since both these functions (shown in Step 6 and Step 7) are functions that will be reused across all the 3 test
cases, you would need to store them in an external function library and associate the function library with all
the 3 test cases. The final code (for the login portion of the script) should look something like this.
'Get the Test Case Name that will be used in fnGetDataFromExcel function
sTestCaseName = Environment.Value("TestName")
'Open GMail
sUrl = fnGetDataFromExcel("URL")
SystemUtil.Run "iexplore.exe", sUrl
'Page Sync
Browser("Gmail").Page("Gmail").Sync
'Login to Gmail
Browser("Gmail").Page("Gmail").WebEdit("UserName").fnSetValue "UserID"
Browser("Gmail").Page("Gmail").WebEdit("Password").fnSetValue "Password"
Browser("Gmail").Page("Gmail").WebButton("SignIn").Click
'Page Sync
Browser("Inbox").Page("Inbox").Sync
Step 10: The above code covers the login portion of the test case where the values are fetched from the
excel sheet. Run this code and check that it is working fine without any errors. Once this is done, you can use
the same steps above to complete this test case and then work on the remaining 2 test cases also.
While adding data for the remaining two test cases, all that you have to do is to add some additional columns
(if required) and add the data in different rows. Once this is done, the custom functions will pick up the
required values based on the test case name and the column names. The below figure shows how the excel
sheet might look like once you add data for
all the test cases in the excel sheet.
This was all about the different
common ways in which you can use
the data driven framework in QTP. If
you are beginner in QTP, I would
recommend that you go through all
the articles on Data Driven Framework
from QTP Framework Main Page link
so that you have a clear idea about the different ways in which you can use the data driven
framework. This would help you understand the entire process and thus you would be in a better
position to choose appropriate framework based on your needs.