After writing the article Working with Multiple Browser Applications with QTP, I thought, there are several instances where automation developers have to work with applications containing multiple windows, in a Standard Windows Environment. This technique uses a similar methodology as demonstrated in the article for Web-based apps, but the crux of this technique differs. It can be used by automation developers testing most types of windows applications, and it contains concepts that are showcased in my generic automation framework RelevantCodes[1]One, which will be released in the coming few weeks.

With the help of this technique, regardless of how many windows applications are opened through QTP, we would never have to keep track of the Window’s title or any of its recognition properties (unless we want to). In other words, regardless of a window’s dynamic nature, this concept will enable you to give the window a name of your choice, and use that name to identify the window, instead of keeping track of changes in its properties.

What this concept contains:

• LaunchAdd: Launch a new window and retain its reference throughout the test cycle
• AddNew: Automatically add a new open window to the collection without you having to specify its properties (see list of dependencies)
• AddCustom: Adds a custom window by specifying its properties as an array
• All identifiers stay intact until the test finishes.

View clsWindow.txt | Download clsWindow.zip | Download Demo v9.2 | Download Demo v9.5

This concept contains 3 main methods, as described above. You can download the Class clsWindow for complete documentation, but for a quick overview, please continue reading.

First, and the one that may be used the most often is a method called AddCustom. It enables users to add a window of their choice to the collection, with the name they want to specify. From that point onwards, regardless of the number of changes that particular window goes through, it will not be required to update its properties. The name you give the window can be used throughout the test cycle. Below is the code snippet for AddCustom:

Public Sub AddCustom(arrPropertyValue, sName)
    Dim lngHwnd
 
    Me.sName = sName
    Me.arrPropertyValue = arrPropertyValue
 
    'Retrieve the handle of the specified window
    lngHwnd = GetCustomWindowHwnd()
 
    'If the handle is valid, then add it to the global collection
    If lngHwnd <> -1 Then
        colObject.Add sName, Window("hwnd:=" & lngHwnd)
        If Not oDict.Exists(lngHwnd) Then
            oDict.Add lngHwnd, lngHwnd
        End If
    End If
End Sub

Next is a method called LaunchAdd, which is dependent upon GetRecentlyOpenWindowHwnd. This will enable you to automatically add a newly launched window to the collection, with the name you specify:

Public Sub LaunchAdd(sFilePath, sName)
    Dim lngHwnd
 
    Me.sFilePath = sFilePath
    Me.sName = sName
 
    'Retrieve the window handle of the recently launched window
    lngHwnd = GetRecentlyOpenWindowHwnd()
 
    'If the handle is valid, then add it to the global collection object
    If lngHwnd <> -1 Then
        colObject.Add sName, Window("hwnd:=" & lngHwnd)
        If Not oDict.Exists(lngHwnd) Then
            oDict.Add lngHwnd, lngHwnd
        End If
    End If
End Sub
 
Private Function GetRecentlyOpenWindowHwnd() 'As Integer
    Dim sFilePath, sName, oDesc, oParent, mHwndDict, x, iTimeElapsed
 
    sFilePath = Me.sFilePath
    sName = Me.sName
 
    GetRecentlyOpenWindowHwnd = -1
 
    On Error Resume Next
 
        'Create a description object
        Set oDesc = Description.Create
 
        'oParent holds references to all the open windows
        Set oParent = Desktop.ChildObjects(oDesc)
 
        'Scripting.Dictionary: holds all open windows' handles
        Set mHwndDict = CreateObject("Scripting.Dictionary")
 
        'Loop until all the handles are successfully added to the collection
        For x = 0 to oParent.Count - 1
            mHwndDict.Add oParent(x).GetROProperty("hwnd"), x
            If Not oDict.Exists(oParent(x).GetROProperty("hwnd")) Then
                oDict.Add oParent(x).GetROProperty("hwnd"), oParent(x).GetROProperty("hwnd")
            End If
        Next
 
        'Launch the target application
        SystemUtil.Run sFilePath
 
        'Loop max 10 seconds for the window to open
        Do
            Set oParent = Desktop.ChildObjects(oDesc)
            For x = 0 to oParent.Count - 1
                Select Case oParent(x).GetTOProperty("micclass")
	       Case "Window", "Dialog"
                        If Not mHwndDict.Exists(oParent(x).GetROProperty("hwnd")) Then
                            GetRecentlyOpenWindowHwnd = oParent(x).GetROProperty("hwnd")
                            Exit Do
                        End If
                End Select
            Next
            Wait(1)
            iTimeElapsed = iTimeElapsed + 1
        Loop Until iTimeElapsed = 10 
 
        Set oDesc = Nothing
        Set oParent = Nothing
        Set mHwndDict = Nothing
 
    On Error Goto 0
End Function

Lastly, and a tricky one is AddNew. This will automatically add any new open window after LaunchAdd has been executed. Like the other 2 methods, this method will also enable preservation of a window’s property until the end of the test.

Public Sub AddNew(sName, iTimeOutBeforeWindowOpens)
    Dim oDesc, oParent, x, iTimeElapsed, lngHwnd
 
    'Set default application timeout
    If iTimeOutBeforeWindowOpens = "" Then
        iTimeOutBeforeWindowOpens = 1
    End If
 
    'Create a Description Object
    Set oDesc = Description.Create
 
    'oParent holds all open windows
    Set oParent = Desktop.ChildObjects(oDesc)
 
    'Wait iTimeOutBeforeWindowOpens number of seconds
    'Default iTimeOutBeforeWindow Opens = 1
    Wait(iTimeOutBeforeWindowOpens)
 
    'Loop for 5 seconds
    'If within 5 seconds, a new unadded window is found, the window will
    ' be added to the collection and this procedure will end.
    Do 
        'Create a new collection
        Set oParent = Desktop.ChildObjects(oDesc)
 
        'Loop for all objects in the collection and find a one that does
        'not exist in the global dictionary: colWindows
        For x = 0 to oParent.Count - 1
            If Not oDict.Exists(oParent(x).GetROProperty("hwnd")) Then
                lngHwnd = oParent(x).GetROProperty("hwnd")
                oDict.Add lngHwnd, lngHwnd
                colObject.Add sName, Window("hwnd:=" & lngHwnd)
                Exit Do
            End If
        Next
        Wait(1)
        iTimeElapsed = iTimeElapsed + 1
    Loop Until iTimeElapsed = 5 'This timeout can be minized to 1, if desired
End Sub

View clsWindow.txt | Download clsWindow.zip | Download Demo v9.2 | Download Demo v9.5

Technically, the concepts in this article can be easily transferred to any technology, just like the concepts were transferred from Web to Windows, which is quite a huge transition. Once this concept is implemented properly, it should help eliminate the need to constantly identify the windows we need to work with.

I hope you find this helpful :)

In this article, we will see a few interesting ways to automate the Windows Calculator. To ensure the concepts in this article are not too overwhelming, I have divided it into 2 parts. The first one discusses a few basics and creates a routine that can be used to easily set values to, and retrieve from it. The concepts in this article should also serve as an excellent way of understanding the automation process with QTP, how functions can help increase code reuse, and why at times its extremely important to validate user-input.

[Off-topic] If you find this article helpful, and would like to see other types of applications automated as well, please post in the comments section and let me know what other applications would be excellent for conceptual purposes and I will try my best to include them in the future articles. [/Off-topic]

Let’s launch the calculator through code:

SystemUtil.Run "calc.exe"

Now, we have the calculator object launched. Let’s see if we can create a few statements in QTP that act as users to perform some calculations. For this example, let’s calculate 10*20:

Window("nativeclass:=SciCalc", "index:=0").WinButton("text:=1").Click	'1 ->   1
Window("nativeclass:=SciCalc", "index:=0").WinButton("text:=0").Click	'0 ->	10
Window("nativeclass:=SciCalc", "index:=0").WinButton("text:=\*").Click	'* ->	10*
Window("nativeclass:=SciCalc", "index:=0").WinButton("text:=2").Click	'2 ->	10*2
Window("nativeclass:=SciCalc", "index:=0").WinButton("text:=0").Click	'0 ->	10*20
Window("nativeclass:=SciCalc", "index:=0").WinButton("text:==").Click	'= ->	10*20=

MsgBox Window("nativeclass:=SciCalc", "index:=0")_
        .WinEdit("nativeclass:=Edit").GetROProperty("text")

Notice we have substitued a “\” before *. This is because * is a special Regex character and all special regex characters must have “\” before them to identify them correctly. You can also execute the same code without the “\” and test the result.

The above code can be simplified using a With..End With statement:

With Window("nativeclass:=SciCalc", "index:=0")
	.WinButton("text:=1").Click    '1 ->    1
	.WinButton("text:=0").Click    '0 ->	10
	.WinButton("text:=\*").Click   '* ->	10*
	.WinButton("text:=2").Click    '2 ->	10*2
	.WinButton("text:=0").Click    '0 ->	10*20
	.WinButton("text:==").Click    '= ->	10*20=

	MsgBox .WinEdit("nativeclass:=Edit").GetROProperty("text")
End With

I covered the above With..End With block because at times when properties change, you only have to update the property of the Window object once, and not 8 times as you would in the previous code snippet.

We can still simplify this process further, by creating a function. With the help of the function, we can avoid writing long and the same lines of code each time we need to perform the same operation. This saves time, and when you need to make changes, it simplifies maintenance and increases code reuse. Let’s create two functions, then. One will type the key, and the other will retrieve the output from the calculator:

'vKey: Key you want to press
Function TypeKey(vKey)
	'* is a special regex character
	'We will put a "\" before it to let QTP know that we are using a literal, not a regex
	Select Case vKey
		Case "*"
			vKey = "\" & vKey
	End Select
 
	With Window("nativeclass:=SciCalc", "index:=0")
		.WinButton("text:=" & vKey).Click
	End With
End Function

Function CalculatedValue
	CalculatedValue = Window("nativeclass:=SciCalc", "index:=0")_
            .WinEdit("nativeclass:=Edit").GetROProperty("text")
End Function

Create a function library and copy both functions in it. Then, go to “File” menu and click “Associate Library [LibraryName] with ‘Test’”. Right now, your library should look something like this:

Function Library with TypeKey and CalculatedValue

Let’s now use the function that we have created above to perform the same calculation. In your test, you will have:

TypeKey "1"
TypeKey "0"
TypeKey "*"
TypeKey "2"
TypeKey "0"
TypeKey "="
 
MsgBox CalculatedValue

Notice how we have compacted our code from the very first code snippet to the one above.

We have already talked about substituting a “\” before a special regex character. The calculator has 5 keys that include such characters. They are:

*
+
+/-
.
M+

We need to incorporate all special regex characters above in our Select-Case block. Thus, we’re now ready to manipulate the TypeKey function above, and create one that will input all sorts of keys from the users, make sure the special characters are followed by a “\” sign, and retrieve the output from the calculator.

Function TypeKey(vKey)
	'Use a Select block for special regex characters
	Select Case vKey
		Case "*", "+", "+/-", "."
			vKey = "\" & vKey
		Case "M+"
			vKey = "M\+"
	End Select
 
	With Window("nativeclass:=SciCalc", "index:=0")
		.WinButton("text:=" & vKey).Click
	End With
End Function

Our function is ready! It is now capable of taking any sort of input from the user and retrieve the output. Let’s put the above function in use:

TypeKey "1"
TypeKey "*"
TypeKey "2"
TypeKey "+"
TypeKey "3"
TypeKey "="
 
MsgBox CalculatedValue

Now, we will begin with the tricky part. Well, not really. This is still the first topic, so we’ll keep it quite easy. We still haven’t created any sort of validation, yet. We are going to manipulate this code a few times and compact it further. We will do this to ensure that our script does not stop because of a user error. For example, if you type “10″ instead of “1″, then “0″, QTP will error out. That is because the calculator does not have any key greater than 9. In other words:

'This is Correct
TypeKey "1"    '1 exists in the calculator
TypeKey "0"    '0 exists in the calculator

'This is incorrect
TypeKey "10"   '10 does not exist in the Calculator

To avoid occurrence of such user errors, we can begin by creating an array of all keys available to the calculator:

Dim arrCalcKeys
 
arrCalcKeys = Array("Backspace", "CE", "C", "MC", "MR", "MS", "M+", "sqt", "%", "1/x", "=", "/",_
                  "*", "-", "+", ".", "+/-", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0")

Now, we can run all our validations against this array. If a user enters any key that is outside this array, that means, there is an error which must be handled. This can help us create a function that will be used solely for purposes of validation. Let’s call it, IsKeyLoaded.

Function IsKeyLoaded(vKey)
	Dim arrCalcKeys, iCalcKey
 
	IsKeyLoaded = False
 
	'Array with all Calculator Keys
	arrCalcKeys = Array("Backspace", "CE", "C", "MC", "MR", "MS", "M+", "sqt", _
			"%", "1/x", "=", "/", "*", "-", "+", ".", "+/-", "1", "2", _
			"3", "4", "5", "6", "7", "8", "9", "0")
 
	'Loop through all Array items and attempt to find vKey
	For Each iCalcKey in arrCalcKeys
		'If the Array Item matches with "vKey", Exit Loop. Return True.
		If CStr(iCalcKey) = CStr(vKey) Then
			IsKeyLoaded = True
			Exit For
		End If
	Next
End Function

IsKeyLoaded contains the array we created above, and a For-Loop that will check the Input Key against the Keys in the Array. If the 2 keys match, we’re good. If the 2 keys don’t match, that means, the user entered an invalid value. But, we’re in the clear because we now have the error handling for that! This also means that because of an invalid input, our script won’t stop.

You won’t believe we have come this far, so quickly. Remember the “TypeKey” function we created earlier? We will incorporate “IsKeyLoaded” in “TypeKey” and create our validation component.

Function TypeKey(vKey)
	'If Key is not found then, Exit Function
	If Not IsKeyLoaded(vKey) Then
		Exit Function
	End If
 
	'Rest of the function remains the same:
	Select Case vKey
		Case "*", "+", "+/-", "."
			vKey = "\" & vKey
		Case "M+"
			vKey = "M\+"
	End Select
 
	With Window("nativeclass:=SciCalc", "index:=0")
		.WinButton("text:=" & vKey).Click
	End With
End Function

Let’s put the code we have created now into practice. We will also use the “CalculatedValue” function we created earlier. For the sake of experiment, let’s provide our function with 2 invalid keys: A and B. Notice how these keys will not be entered to the Calculator, instead, the function will exit if it finds anything that is outside the scope of our array: arrCalcKeys.

TypeKey "A"	'Ignore
TypeKey "1"	'Valid
TypeKey "B"	'Ignore
TypeKey "2"	'Valid
TypeKey "3"	'Valid
TypeKey "+"	'Valid
TypeKey "1"	'Valid
TypeKey "="	'Valid

MsgBox CalculatedValue '124

Execution Result

Our script didn’t stop regardless of the user error, and was able to retrieve the output nonetheless. However, there is a BIG short-coming in our code. If the user meant to type “0″ and they typed “A”, “B” or any other key, that means, even though our script didn’t stop, it calculated an incorrect value. A small error at times can go unnoticed, and it can become a cause of concern for the automation developer as well as the user. Thus, we must incorporate additional logic that will let us know if an invalid key was calculated; and the output should be discarded. We will see that, and much more in the coming article!

In this article we learned how we can begin from scratch and create a highly usable code block. In the next article, we will cover advanced techniques, and you will see how code can be compacted further, and how code reuse can be enhanced. Above all, we will learn why we must be sharp in reporting errors that a user might miss. Sometimes, our extra attention to detail can save an entire team a lot of time. Plus, your role automatically becomes more important to the success of the team.