QTP AOM Scripts

'Script To open QTP and run Test

Dim app
set app=CreateObject("QuickTest.Application")
app.launch
app.visible=True
app.open "E:\ahamad\Test1"

''Script to connect to Quality Center From QTP
Set app=CreateObject("QuickTest.Application")
app.Launch
app.Visible = True
app.TDConnection.Connect "QCURL","DOMAIN","PROJECT","USERNAME","PASSWORD",False
''Example : app.TDConnection.Connect "http://192.168.1.1:8080/qcbin","Default","proj1","ahamad",,false

'''Script to Connect to QC and Add a new Defect in QC from QTP
Dim qccon
Set qccon=CreateObject("TDApiOle.TDConnection")
qccon.InitConnection "http://qcserverurl:8080/qcbin"
qccon.ConnectProject "proj1","ahamad",""
If qccon.Connected Then
    Msgbox "Connected to QC Server
Else
   MsgBox "Not Connected"
End If

Set BugFactory = qccon.BugFactory
Set Bug = BugFactory.AddItem(Nothing)
Bug.Status = "New"
Bug.Summary = "Error in login"
Bug.Priority = "4-Very High"
Bug.AssignedTo ="user1"
Bug.DetectedBy = "ahamad"
Bug.Post

' Close QTP After execution of the Test
set wm=GetObject("winmgmts:\\.\root\CIMV2")
Set pros=wmi.ExecQuery("Select * from Win32_Process Where Name = 'QTPro.exe'")
For Each p in pros
   p.Terminate()
Next
Set wmi=Nothing
Set pros=Nothing

Real Time Descriptive Programming

Descriptive Programming

Let’s get on with a simple program to understand this concept.

On Performing a Record function using QTP on a program (Assumption – Program static in Nature), The Quick test recognizes the appropriate object used and adds them to the repository.  On executing the quick test program, the application would execute without any errors because the QTP would use the Mandatory\Assistive properties to recognize the objects used in the program.

Assume a new Textbox object is displayed with Properties which are dynamically generated. For e.g. name property is generated dynamically based on the current date like ‘TextB_2007_01_01”. Now when this object is added to the repository, the possibility of QTP program working is very less.

The ideal solution is set to set the name property at runtime i.e. write a code and set the property of the variable.

 ‘Assumption it is a webedit box

Dim curr_date

Curr_date = year (now) &”_”& Month (now) &"_"& Day (now)

‘Curr_date would contain the current date. For e.g. Curr_date = “2007_01_01”

 Browser (“…”).Page (“….”).Webedit (“Name: = TextB_” & Curr_date).Set “Hello”

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 syntax is:

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

Why and when do we need Descriptive Programming

Possible reasons to use Descriptive Programming are

When the object properties used in the application are dynamic in nature i.e. to be more precise the properties used to recognize are not constant and requires special handling.

To restrict the object repository to a limited size to avoid performance execution issues.

When the application to tested is not developed completely for testing and designing of Automation scripts need to commence.

Also some certain scenarios, where the Object or the control cannot be recognized. This will be dealt in the forthcoming sections.

Things to do to understand Descriptive Programming

In order to exercise the benefits of descriptive programming, the user has to follow at least the minimum guidelines give below           

Understand the Object or control which requires descriptive programming.

This would revolve around understanding various properties of object and should answer questions such as what is the Class \ MICLASS property of the object? This property holds values such as whether it is Webedit or IMAGE or WEBLIST.

Can the Object be uniquely recognized with available properties such as Name, ID, HTML TAG?

Is the Object just required to recognize sub elements within object?

Assume a Web application named “DEMO” needs to be tested. The Application is designed such that browser title keeps changing based on the module.

Always the title has “DEMO:” as a Constant string followed by the module name.

Now in an Object Repository, instead of storing multiple Browser objects in the repository. The user can use regular expression to such as “DEMO : .*”.

This would help in recognizing the sub elements provided the user Checks the regular expression property.

If these are .NET custom controls, Refer the QTP Help.

What’s a Description Object?

This is a generic object which can be used to mould (i.e. programmatically configured) itself as an object in the application.

Assume a Webedit object needs to use to set data.

‘ Create a Generic description using the below syntax

Set EditDesc = Description.Create()

EditDesc("Name").Value = "userName"

EditDesc("Index").Value = "1"

Browser("…").Page("….").WebEdit(EditDesc).Set "MyName"

Let’s take this above example to a different level.

Various methods of using Description Object

Now you want to count the number of webedit objects in a Web table.

Here are going to use CHILDOBJECTS property of web table to solve.

‘Define you Webedit object using the properties you require.

Set editdesc=Description.create()

Edit(“micclass”).value=”Webedit”

Set ctr=Browser(“…”).Page(“…”).Webtable(“TABLE1”).Childobjects(editdesc)

‘Ctr object here is an array of objects where each object is similar to ‘description object

Msgbox ctr.count

To print the name of each element in this array we can do the following

For i = 0 to ubound(ctr)

            Msgbox Ctr(i).Name

Next

To skim through the properties of each webedit object in the array

Set editdesc=Description.create()

Edit(“micclass”).value=”Webedit”

Set wbtab_arr =Browser(“…”).Page(“…”).Webtable(“TABLE1”).Childobjects(editdesc)

For each obj1 in wbtab_arr

Temp_name = Obj1.Name

Temp_value = obj1.value

Next

To scan the properties of web object.

Let’s take webtable and proceed

Set wbtab_prop =Browser(“…”).Page(“…”).Webtable(“TABLE1”). GetTOProperties

            For k= 0 to wbtab_prop.count – 1

                        Msgbox Wbtab_prop(i).name

                        Msgbox wbtab_prop(i).value

            Next

Note: For Regular expression, use the wbtab_prop(i).regularexpression.

Tips and Tricks which can be used in a Description Programming

Navigating through each Cell in a Web table.

Webtabobj= Browser(…).Page(“….”).Webtable(“table1”).object

Rowcnt= Webtabobj.Rowcount

For i = 1 to Rowcnt

            For j = 1 to Webtabobj. ColumnCount(i)

                                    Msgbox Webtabobj.getcelldata (i,j)

            Next

Next

Setting value “TEST1” in all the webedit controls in a webtable

            Webtabobj= Browser(…).Page(“….”).Webtable(“table1”).object

Rowcnt= Webtabobj.Rowcount

For i = 1 to Rowcnt

                        For j = 1 to Webtabobj. ColumnCount(i)

                                                Set tempwebedit= webtabobj.chilitem(i,j,”Webedit”,0)

                                                Tempwebedit.set “TEST1”

                        Next

Next

Setting up property of object dynamically

We can use either use an environment variable or Set to property to perform this .

You can declare a environment variable in the QTP script.

            Environment(“Demotitle”)= “DEMO:.*”

            ‘Check the Regular expression Check Box if necessary

Using “Set to property” also we achieve this task.

            Syntax : object.SetTOProperty Property, Value

Removing property of an object dynamically

Syntax : object.Remove “Property”

e.g:

                                    ‘to delete the html tag property from the collection

                                     object.remove “html tag”

The following points will also be covered

Get all elements in HTML tag

Active element in webpage

  

Descriptive programming in QTP

Descriptive programming in QTP

Introduction:

This document demonstrates the usage of Descriptive programming in QTP. It also discusses situations where Descriptive programming can be used. Using Descriptive Programming automation scripts can be created even if the application has not been developed.

Descriptive Programming:

Whenever QTP records any action on any object of an application, it adds some description on how to recognize that object to a repository of objects called object repository. QTP cannot take action on an object until unless its object description is in the Object Repository. But descriptive programming provides a way to perform action on objects which are not in Object repository

Object Identification:

To identify an object during the play back of the scripts QTP stores some properties which helps QTP to uniquely identify the object on a page. Below screen shots shows an example Object repository:

Now to recognize a radio button on a page QTP had added 2 properties the name of the radio button and the html tag for it. The name the left tree view is the logical name given by QTP for the object. This can be changed as per the convenience of the person writing the test case. QTP only allows UNIQUE logical name under same level of hierarchy. As we see in the snapshot the two objects in Browser->Page node are “WebTable” and “testPath”, they cannot have the same logical name. But an object under some other node can have the same name. Now with the current repository that we have, we can only write operation on objects which are in the repository. Some of the example operations are given below

Browser("Browser").Page("Page").WebRadioGroup ("testPath").Select "2"

cellData = Browser("Browser").Page("Page").WebTable ("WebTable").GetCellData (1,1)

Browser("Example2").Page("Page").WebEdit("testPath").Set "Test text"

When and Why to use Descriptive programming?

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

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 <<UserName>>”.

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.

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.

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.

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.

How to use Descriptive programming?

There are two ways in which descriptive programming can be used

By creating properties collection object for the description.

By giving the description in form of the string arguments.

By creating properties collection object for the description.

To use this method you need first to create an empty description

Dim obj_Desc ‘Not necessary to declare

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 of 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 1^st textbox:

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

obj_Desc(“name”).value= “txt_Name”

obj_Desc(“index”).value= “0”

For 2^nd 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.

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).

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”

Next

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 i.e. we can’t use the string arguments that will be discussed later in the 2nd way of using the programming description.

Possible Operation on Description Object

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  1^st:

                 For each desc in obj_ChkDesc

                                                Name=desc.Name

                                                Value=desc.Value

                                                RE = desc.regularexpression

                                Next

                2^nd:

                              For i=0 to obj_ChkDesc.count - 1

                                                Name= obj_ChkDesc(i).Name

                                                Value= obj_ChkDesc(i).Value

                                                RE = obj_ChkDesc(i).regularexpression

                                Next

By giving the description in form of the string arguments.

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

Examples

'Script for Login
Systemutil.Run "C:\Program Files\HP\QuickTest Professional\samples\flight\app\flight4a.exe"
with Dialog("text:=Login")
.WinEdit("attached text:=Agent Name:").set "abcd"
.WinEdit("attached text:=Password:").set "mercury"
.WinButton("text:=OK").click
End with
'Script for Insert new Record

 With Window("text:=Flight Reservation")
.WinMenu("menuobjtype:=2").Select "File;New Order"
.ActiveX("acx_name:=MaskEdBox").Type "062610"
.WinCombobox("attached text:=Fly From:").Select "Denver"
.WinComboBox("attached text:=Fly To:").Select "Paris"
.WinButton("text:=FLIGHT").Click
.Dialog("text:=Flights Table").WinList("attached text:=From","nativeclass:=ListBox").Select 1
.Dialog("text:=Flights Table").WinButton("text:=OK").Click
.WinEdit("attached text:=Name:","nativeclass:=Edit").Set "james"
.WinButton("text:=&Insert Order").click
End With'

Script for open Record
With window("text:=Flight Reservation")
.WinMenu("menuobjtype:=2").Select "File;Open Order..."
with .Dialog("text:=Open Order")
.WinCheckBox("text:=&Order No.").Set "ON"
.WinEdit("window id:=1016").Set "1"
.WinButton("text:=OK").Click
End With
End With

QC API and QTP AOM Scripts

Connect to QC and Add a New Defect
----------------------------------------------------
Dim qccon
Set qccon=CreateObject("TDApiOle80.TDConnection")
qccon.InitConnectionEx "http://qcserverurl:8080/qcbin"
qccon.login "username","password"
qccon.Connect "DEFAULT","QualityCenter_Demo"
Set BugFactory = qccon.BugFactory
Set Bug = BugFactory.AddItem(Nothing)
Bug.Status = "New"
Bug.Summary = "Error in login"
Bug.Priority = "4-Very High"
Bug.AssignedTo ="user1"
Bug.DetectedBy = "venkat"
Bug.Post
------------------------------------------------
Connect to QC and Read all the Defects and Write in Excel
-------------------------------------------------
Dim qc,bgf,bglist,xl,ws,b,r
Set qc=CreateObject("TDApiOle80.TDConnection")
qc.InitConnectionEx "http://localhost:8080/qcbin"
qc.login "admin", "mindq"
qc.Connect "DEFAULT","QualityCenter_Demo"
Set bgf = qc.BugFactory
Set bglist = bgf.NewList("")
Set xl=CreateObject("Excel.Application")
xl.WorkBooks.Add()
Set ws=xl.ActiveSheet
r=1
For Each b In bglist
ws.Cells(r, 1).Value =b.Field("BG_BUG_ID")
ws.Cells(r, 2).Value = b.Summary
ws.Cells(r, 3).Value = b.DetectedBy
ws.Cells(r, 4).Value = b.Priority
ws.Cells(r, 5).Value = b.Status
ws.Cells(r, 6).Value = b.AssignedTo
r=r+1
Next
xl.ActiveWorkbook.SaveAs("C:\QC_Demo_defects.xls")
xl.Quit
===========================================
 To open QTP Test and count the number of repositories associated
----------------------------------------------------------------
Dim app
set app=CreateObject("QuickTest.Application")
app.launch
app.visible=True
app.open "c:\test1",False
set r=app.Test.Actions("Action1").ObjectRepositories
msgbox "Total ORs :"&r.count
for i=1 to r.count
msgbox "Path of OR :"&r.item(i)
next
app.quit
set r=nothing
set app=nothing
------------------------------------------------------------------
To count the recovery scenarios associated to the test
-------------------------------------------------------------------
dim app
set app=CreateObject("QuickTest.Application")
app.launch
app.open "c:\test1",false
app.visible=True
set rs=app.Test.settings.Recovery
if rs.count>0 then
redim a(rs.count)
for i=0 to rs.count
a(i)=rs.item(i+1).name
i=i+1
next
end if
print "The recovery scenarios associated to the test are"
for i=0 to ubound(a)
print a(i)
next
----------------------------------------------------------
script to display the list of actions and their details
----------------------------------------------------------
Dim app
set app=CreateObject("QuickTest.Application")
app.launch
app.visible=True
app.open "c:\test1"
redim a(app.Test.Actions.count)
for i=1 to app.Test.Actions.count
a(i-1)=app.Test.Actions.item(i).name&" "&app.Test.Actions.item(i).type&" "&app.Test.Actions.item(i).location
next
for i=0 to ubount(a)
print a(i)
next
=========================================

Tips to Get Started with Automated Testing

1. Decide what Test Cases to Automate
2. Test Early and Test Often
3. Select the Right Automated Testing Tool
4. Divide your Automated Testing Efforts
5. Create Good, Quality Test Data
6. Create Automated Tests that are Resistant to Changes in the UI

1. Decide What Test Cases to Automate

1. It is impossible to automate all testing, the first step to successful automation is to determine what test cases should be automated first.
2. The benefit of automated testing is correlated with how many times a given test can be repeated. Tests that are only performed a few times are better left for manual testing. Good test cases for automation are those that are run frequently and require large amounts of data to perform the same action.
3. You can get the most benefit out of your automated testing efforts by automating:
4. Repetitive tests that run for multiple builds
5. Tests that are highly subject to human error
6. Tests that require multiple data sets
7. Frequently-used functionality that introduces high risk conditions
8. Tests that are impossible to perform manually
9. Tests that run on several different hardware or software platforms and configurations
10. Tests that take a lot of effort and time when doing manual testing
11. Tips to Getting Started with Automated Testing

Success in test automation requires careful planning and design work. Start out by creating an automation plan. This plan allows you to identify the initial set of tests to automate, and serve as a guide for future tests. First, you should define your goal for automated testing and determine which types of tests to automate. There are a few different types of testing, and each has its place in the testing process. For instance, unit testing is used to test a small part of the intended application. Load testing is performed when you need to know how a web service responds under a heavy workload. To test a certain piece of the application’s UI, you would use functional or GUI testing.

After determining your goal and which types of tests to automate, you should decide what actions your automated tests will perform. Don’t just create test steps that test various aspects of the application’s behavior at one time. Large, complex automated tests are difficult to edit and debug. It is best to divide your tests into several logical, smaller tests. This structure makes your test environment more coherent and manageable and allows you to share test code, test data and processes. You will get more opportunities to update your automated tests just by adding small tests that address new functionality. Test the functionality of your application as you add it, rather than waiting until the whole feature is implemented.

When creating tests, try to keep them small and focused on one objective. For example, use separate tests for read-only versus read/write tests. This separation allows you to use these individual tests repeatedly without including them in every automated test.

Once you create several simple automated tests, you can group your tests into one, larger automated test. You can organize automated tests by the application’s functional area, major/minor division in the application, common functions or a base set of test data. If an automated test refers to other tests, you may need to create a test tree, where you can run tests in a specific order.

2. Test Early and Test Often

To get the most out of your automated testing, testing should be started as early as possible in the development cycle and run as often as needed. The earlier testers get involved in the life cycle of the project the better, and the more you test, the more bugs you find. You can implement automated unit testing on day one and then you can gradually build your automated test suite. Bugs detected early are a lot cheaper to fix than those discovered later in production or deployment.

3. Select the Right Automated Testing Tool

Selecting an automated testing tool is essential for test automation. There are a lot of automated testing tools on the market, and it is important to choose the tool that best suits your overall requirements. 3 6 Tips to Getting Started with Automated Testing

Consider these key points when selecting an automated testing tool:

Support for your platforms and technology. Are you testing .Net, C# or WPF applications and on what operating systems?

Flexibility for testers of all skill levels. Can your QA department write automated test scripts or is there a need for keyword testing?

Feature-rich but also easy to create automated tests. Does the automated testing tool support record-and-playback test creation as well as manual creation of automated tests? Does it include features for implementing checkpoints to verify values, databases, or key functionality of your application?

Create automated tests that are reusable, maintainable and resistant to changes in the applications UI. Will your automated tests break if your UI changes?

For detailed information about selecting automated testing tools for automated testing, see our Whitepaper “Selecting Automated Testing Tools”.

4. Divide Your Automated Testing Efforts

Usually, the creation of different tests is based on the skill level of the QA engineers. It is important to identify the level of experience and skills for each of your team members and divide your automated testing efforts accordingly. For instance, writing automated test scripts requires expert knowledge of scripting languages. Thus, in order to perform that task, you should have QA engineers that know the script language provided by the automated testing tool.

Some team members may not be versed in writing automated test scripts. These QA engineers may be better at writing test cases. It is better when an automated testing tool has a way to create automated tests that does not require an in-depth knowledge of scripting languages, like TestComplete’s “keyword tests” capability. A keyword test (also known as keyword-driven testing) is a simple series of keywords with a specified action. With keyword tests, you can simulate keystrokes, click buttons, select menu items, call object methods and properties, and do a lot more. Keyword tests are often seen as an alternative to automated test scripts. Unlike scripts, they can be easily used by technical and non-technical users and allow users of all levels to create robust and powerful automated tests.

You should also collaborate on your automated testing project with other QA engineers in your department. Testing performed by a team is more effective for finding defects and the right automated testing tool should allow you to share your projects with several testers.

5. Create Good, Quality Test Data

Good test data is extremely useful for data-driven testing. The data that should be entered into input fields during an automated test is usually stored in an external file. This data might be read from a database or any other data source like text or XML files, Excel sheets, and database tables. A good automated testing tool actually understands the contents of the data files and 4 6 Tips to Getting Started with Automated Testing

iterates over the contents in the automated test. Using external data makes your automated tests reusable and easier to maintain. To add different testing scenarios, the data files can be easily extended with new data without needing to edit the actual automated test.

Creating test data for your automated tests is boring, but you should invest time and effort into creating data that is well structured. With good test data available, writing automated tests becomes a lot easier. The earlier you create good-quality data, the easier it is to extend existing automated tests along with the application's development.

6. Create Automated Tests that are Resistant to Changes in the UI

Automated tests created with scripts or keyword tests are dependent on the application under test. The user interface of the application may change between builds, especially in the early stages. These changes may affect the test results, or your automated tests may no longer work with future versions of the application.

The problem is that automated testing tools use a series of properties to identify and locate an object. Sometimes a testing tool relies on location coordinates to find the object. For instance, if the control caption or its location has changed, the automated test will no longer be able to find the object when it runs and will fail. To run the automated test successfully, you may need to replace old names with new ones in the entire project, before running the test against the new version of the application. However, if you provide unique names for your controls, it makes your automated tests resistant to these UI changes and ensures that your automated tests work without having to make changes to the test itself. This best practice also prevents the automated testing tool from relying

waterfall model-Advantages&Disadvantage

Waterfall Model

History of the Waterfall Model

On the origin of the term “waterfall” is often said that Winston Royce introduced it in 1970, but Royce saw themselves more in the repeated approach to software development and even used the term “waterfall”. Royce described the waterfall model as a method he ventured even an invitation to failure occurred. In 1970 Royce was that the waterfall model should be seen as the first draft, he felt that the method has flaws. He brought a document which examined how the initial concept to a recurrent method could be developed, this new model in each phase was between a feedback to the previous stage, as we now see in many current methods. Royce was just annoying for the initial focus method, the criticism he had on this method was largely ignored Despite Royces intentions to the waterfall model into a repeat method (iterative model), the use of this method is still very popular, but opponents of the waterfall model see it as a naive and inappropriate method for use in the real world “.

The waterfall model consists of the following phases:

Definition study / analysis. Research is being conducted and to brainstorm about the software to get clear what the purpose of the software. Basic design. It clearly worked out what happened during the first phase unearthed. In this phase, the customer put on paper and has been given to the shape of the program. This phase is set to deliver what it has to do. Technical design / detail design. Using the basic design can be thought of an actual program. In this phase determines how the functionality defined in the basic design will be realized. Now is also a place subdivision in engineering units such as programs, modules and functions. Construction / implementation. Here is the source code of programs written. Testing. It checks whether the software is built right to the designs. Also at this stage errors that surfaced in earlier stages made. Integration. The system is ready and tested. It will however take the company to be put into use. This is done in this phase. Management and maintenance. In order to ensure that the system will continue to do maintenance to be performed. The waterfall model consists of several stages. Each phase has its own level also determines the order. The highest level is performed first and then the lower stages. This is equal to the natural functioning of a waterfall and hence the name. Above clearly shows that the various phases from top to bottom.

Pro’s and Con’s

Advantages

If in the beginning of the project failures are detected, it takes less effort (and therefore time and money) for this error. In the waterfall model phases to be properly sealed first before proceeding to the next stage. It is believed that the phases are correct before proceeding to the next phase. In the waterfall model lay the emphasis on documentation. In the newer software development methodologies makes it less documentation. This means that when new people in the project, and people leave it is difficult to transfer knowledge. This disadvantage is not the traditional waterfall model. It is a straightforward method. The way of working ensures that there are specific phases. This tells you what stage it is. One can use this method of milestones. Milestones can be used to monitor the progress of the project to estimate. The waterfall model is well known. Many people have experienced, so there might be easy to work. When frequent portions of the software product to be delivered this gives the customer confidence, but also the software development team.

Disadvantages

There are some disadvantages of this way to develop software. Many software projects are dependent on external factors. The client is a very important external factor. Often the requirements over the course of the project change, because the client wants something different. It is a disadvantage that the waterfall model assumes that the requirements will not change during the project. When a requirement changes in the construction phase, a substantial number of phases made again. It is very difficult to time and cost estimate. The phases are very large, it is therefore very difficult to estimate how much each step cost. In a number of new methods are almost all aspects of a software development process included. One can think of planning techniques, project management methods and how the project should be organized. In many software projects, different people at different stages of the project. For example: the designers and builders. They all have a different view of the project as designers look at the project differently than the builders. Conversely, the builders often different from the design of the designers look than the designers themselves. Frequently, the design will be adjusted again. Here is the waterfall model is not made for that. Within the project the team members often specialized. One team member will be only the first phase involved the design, while the only builders in construction helping to build the project. This can lead to waste of different sources. The main source is the time. An example: the designers are working on perfecting the design. The builders are in principle already start building, but because they work with the waterfall model, they should wait until the first phase is complete. This is a typical example of wasted time. Testing is done only in one of the last phases of the project. In many other software development methods will be tested once a certain part and finished product is at last an integration test. Because so much emphasis on documentation, the waterfall model is not efficient for smaller projects. There’s too much effort to the project itself around in terms of documentation.