GUI tests automation - Tutorial

Note

Introduction

This document may serve as a tutorial on 2 topics – using perl module Win32::GuiTest and on the basics of automated testing of Gui applications. The untented audience are perl developers, who want to use Win32::GuiTest, and all other people who maybe interested in knowing what is automated GUI testing all about.

Prerequisites

You may just read the tutorial. It should give a good understanding of how is GUI automation implemented. But it would be much more effective if you practice all examples, which are given in this document. In order to do it, you should have the following software in place:

• WinNT/2K/XP system

• Perl with Win32::GuiTest module installed

• WinSpy – you can get it from http://www.catch22.net/software/winspy.asp
  

Terminology

In order to avoid confuses, I will use the term Win32 in order to refer to WinNT/2K/XP operating system.

Let's start

Although it is not always true we can say that generally, all windows which are opened on your screen are system objects. Win32 keeps track of them and can give information about them. Let's practice from the very beginning. Launch the calculator application available in Win32 systems. On my machine it looks like this:

If it does not look like this on your machine, go to „View” menu in Calculator and choose "standard". Although keeping "scientific" will not do any harm, using the standard version will help us avoid confusion.

Now run WinSpy.

Once you played a little bit, we can come back to Calculator.

Imagine that you want to automate the following scenario:

• Using keyboard calculate 2+5.

• Launch the Calculator application or if it is opened – click on it.

• Type the right keys

Actually, in the step one, clicking on the opened application (or using Alt-Tab to switch to this application) is a way of doing something important. You move the input focus to Calculator. In Win32, window needs to have a focus in order to receive all input from the keyboard. When you have several applications opened, and you type something, only one application, this with the input focus, actually react on what you type.

Of course, if you are using Win32 for different language (like Polish), You will have to change the search title to the right one ("Kalkulator" for Polish).

FindWindowLike returns a list of window handles. Window handle uniquely identifies a window in the system. In any time, there could be only one window with the given window handle, which is a long number.

Why does it return a list? We want only one window, don't we? FindWindowLike is a flexible function, which allows to specify search conditions for the group of windows. In that case, it will return handles of all windows, which satisfy these conditions. In our call, we specify that we are looking for a window with title "Calculator". In most cases only Calculator window will match. However, if there is another window opened which contains "Calculator" string in its title, its handle will also be returned. The second parameter of FindWindowLike function is treated as a regular expression to match with all windows' titles.

Try to run it now. If your calculator application is opened you should get something like:

So we have found the window. Now we have to move focus to the window and then type the right keys.

We move focus using function SetForegroundWindow. And we send keys using SendKeys.

Let's try. When you run the script, the Calculator's window will move to front and then it will display "7" (before it displays "7", it will also display "2" and "5", however it would be done so quickly, that you will not notice that).

Have a look at WinSpy again. Notice that Calculator item in WinSpy tree has a plus. Plus suggests that you can expand an item and find something more in it. Let's do it.

Find the window, which is a "2" button. Click it. Look what WinSpy says about it. It gives you the window handle. It also display information about control id.

Our "buttoned" test will look like this:

• Find a window

• Push all necessary buttons.

You push a button by calling PushChildButton. It takes 2 arguments : window handle of the window on which the button is placed (parent window), and the control id of the button you want to push.

Here is the code:

use Win32::GuiTest qw( FindWindowLike
                       PushChildButton );
use strict;

my @whnds = FindWindowLike( undef, "^Calculator" );
if( !@whnds ){
    die "Cannot find window with title/caption Calculator\n";
}else{
    printf( "Window handle of calculator application is %x\n", $whnds[ 0 ] );
}
PushChildButton( $whnds[ 0 ], 126 ); # Button 2
PushChildButton( $whnds[ 0 ], 92 );  # Button +
PushChildButton( $whnds[ 0 ], 129 ); # Button 5
PushChildButton( $whnds[ 0 ], 112 ); # Button =

Notice that you do not have to move the input focus to Calculator. That's because you specify exactly, which button in which window you want to push.

Run it. Again, Calculator should display 7.

We are now able, to make the script doing typing and pushing for us. The really automated test also requires that the results are automatically checked. So the thing we miss is checking if when adding 2 and 5 Calculator actually displays 7.

We have to go back to WinSpy again. On the very beginning of controls belonging to Calculator, there should be a control of type "Edit". As you may guess, Edit control is also a window, with some special features, like displaying a text. You get the contents of the Edit control by calling WMGetText. It takes as a parameter a window handle of the Edit control. So in order to use it in our code, we have to find out a window handle for the Edit control. We actually have to implement finding this handle. We cannot hard code it, since you never know what would be the window handle of any window. But when you have the control id and window handle of a window, which is a parent of the Edit control, you can easily get window handle of that control. The function, which is going to help you is again FindWindowLike.

First the script, then the explanation:

You should get something like this:

Congratulations! You've done the fully automated GUI test.

Going further

As you can see, the basic concepts behind automated gui testing are not that difficult. However, I have some bad news for you. Gui testing is more complex then it appears after reading this tutorial. The one object – one window pattern is not followed even for some basic controls. One of them is toolbar. If you examine with WinSpy any application containing a toolbar, you will see that WinSpy sees only one window – the toolbar. Buttons on the toolbar are not seperate windows. So you can't work with toolbar in a way you did with calculator. We need to use some more sophisticated mechanisms.

Also, some types of applications are seen by the system as one window with no children. Java applications behave this way. No matter how many controls they have, they are seen as single window by Win32 (and, what follows, by WinSpy).

But there is still much interesting stuff you can do with Win32::GuiTest perl module.

Recommended reading.

• perlguitest group at yahoo: http://groups.yahoo.com/group/perlguitest/join
• Winguitest project on Source Forge: http://sourceforge.net/projects/winguitest
  

If you have some experience with perl, look at the module's documentation and the code. Look at provided examples and the test code. They are excellent in explaining how the whole thing works. If you also know C, try to get .xs file. You will see that many functions are actually simple wrappers for Win32 functions.

Understanding Win32 windowing mechanisms would be a big help. I can recommend you the following books:

• Programming Windows 5^th edition, by Charles Petzold – I can't say anything original here. Excellent book on Windows, a must read for someone who wants to get a grasp of what are Win32 all about.

• Programming Applications for MS Windows 4^th edition, by Jeffrey Richter – Another excellent book. Compared with Petzold, this book focuses more on system internals, whereas Petzold focuses on stuff related to windowing.

• Programming Windows with MFC (2^nd edition), by Jeff Prosise – Called "Petzold for MFC". Contains good explanation for toolbars and other controls.

• Documentation for Win32 API can be found on Microsoft's MSDN.

If you liked this tutorial, you can also check my website www.piotrkaluski.com. Who knows, maybe I will write more :)

Comments

If you found any errors, typos (don't be shy to bother me about typos) or have any kind of comments, send me an e-mail: pkaluski@piotrkaluski.com.