GUI Automated Testing

Sharing .xaml in WPF and Silverlight

2011-11-13T20:06:00.000+01:00

Sharing code between WPF and Silverlight is not difficult. Good how-to is in the Prism guide. However sharing more complex .xaml is not so easy. You have to handle different namespaces and properties.

Handling different namespaces

Silverlight toolkit components are accessible via special namespace. So if you want to use a WrapPanel in Silverlight, you write something like this:


<UserControl x:Class="UnifiedXaml.TestControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:toolkit="http://schemas.microsoft.com/winfx/2006/xaml/presentation/toolkit">
    <toolkit:WrapPanel></toolkit:WrapPanel>
</UserControl>

WPF world is easier:


<UserControl x:Class="UnifiedXaml.TestControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <WrapPanel></WrapPanel>
</UserControl>

It's clear those two .xaml files are so similar that they should be just one file. Here is one tiny line that makes it possible:


namespace UnifiedXaml
{
    public class MyWrapPanel: WrapPanel { }
}

From now on, you can share the .xaml file:


<UserControl x:Class="UnifiedXaml.TestControl"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:ux="clr-namespace:UnifiedXaml">
    <ux:MyWrapPanel></ux:MyWrapPanel>
</UserControl>

Handling different properties

When you follow Prism guidelines, you have separate projects for WPF and Silverlight parts. That means the WPF/SL application resources dictionaries are also separate. So the easiest way to handle different properties is to use styles. Shared .xaml file specifies just the control and its style. All necessary properties for WPF are defined in the style stored in the WPF application resources dictionary and the same is done for Silverlight.

Anonymous function as default argument in methods

2010-09-10T20:25:00.000+02:00

I was quite surprised by Python recently when I tried to use anonymous function that uses a class method (not classmethod) as a default argument for another class method and it worked. Example is worth thousands words so here it is:


class ListObject(object):
    items = ((1, 'one'), (2, 'two'), (3, 'three'))

    def get_num(self, item):
        return item[0]

    def get_text(self, item):
        return item[1]

    def get_list(self, fn=lambda s, i: ListObject.get_num(s, i)):
        return [fn(self, j) for j in self.items]

lo = ListObject()
print 'numbers:', lo.get_list()
print 'texts:', lo.get_list(ListObject.get_text)
print 'texts:', lo.get_list(lambda s, i: i[1])
print 'items:', lo.get_list(lambda s, i: i)

When you run this piece of code you get what you want:


numbers: [1, 2, 3]
texts: ['one', 'two', 'three']
texts: ['one', 'two', 'three']
items: [(1, 'one'), (2, 'two'), (3, 'three')]

By default, get_list method uses get_num method and apply it to all items. But you can supply your own fucntion to apply it on items.

Of course, this is very stupid example but it shows the principle. And this principle is quite handy for UI automation I am currently working on :-)

Distributing Silverlight application written in IronPython

2010-05-16T16:44:00.004+02:00

When you have Silverlight application written in IronPython, it is a goodidea to split it to several files so browser can cache them separately. Later,when you change something in your application, users will download only a smallpart. During my attemts with IronPython and Silverligt, I have foundseveral catches. That's why I describe here my way how to distribute IronPythonSilverlight application.

I distribute my application as one .html file, one.xap file, and several .zipfiles. I use .zip because IIS already knows what to dowith .zip files. The files are:

index.html
app.xap
IronPython.zip - contains files from IronPython-2.6.1\Silverlight\bin:
```
IronPython.dll
IronPython.Modules.dll
```

Microsoft.Scripting.zip - contains files from IronPython-2.6.1\Silverlight\bin:


Microsoft.Dynamic.dll
Microsoft.Scripting.dll
Microsoft.Scripting.Core.dll
Microsoft.Scripting.ExtensionAttribute.dll
Microsoft.Scripting.Silverlight.dll

SLToolkit.zip - contains files form Silverlight toolkit or SDK; in our case just


System.Windows.Controls.dll

Let's create a small application, that uses ChildWindow control fromSilverlight toolkit:


C:\IronPython-2.6.1\Silverlight\script\sl.bat python childwindow

Change the app.py and app.xml:

app.py


from System.Windows import Application
from System.Windows.Controls import UserControl

class App:
    def __init__(self):
        self.root = Application.Current.LoadRootVisual(UserControl(), "app.xaml")

a = App()

app.xaml


<UserControl x:Class="System.Windows.Controls.UserControl"
  xmlns="http://schemas.microsoft.com/client/2007"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls">
  <controls:ChildWindow >
    <StackPanel>
      <TextBlock Text="Text in ChildWindow"/>
      <Button x:Name="btnNewWindow" Content="New window"/>
    </StackPanel>
  </controls:ChildWindow>
</UserControl>

We don't want to Chiron automatically add necesary .dll files into .xap so we have toadd our own AppManifest.xaml and languages.config into childwindow\appfolder:

AppManifest.xaml


<Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  RuntimeVersion="2.0.31005.0"
  EntryPointAssembly="Microsoft.Scripting.Silverlight"
  EntryPointType="Microsoft.Scripting.Silverlight.DynamicApplication"
  ExternalCallersFromCrossDomain="ScriptableOnly">
  <Deployment.Parts>
  </Deployment.Parts>
  <Deployment.ExternalParts>
    <ExtensionPart Source="Microsoft.Scripting.zip" />
    <ExtensionPart Source="SLToolkit.zip" />
  </Deployment.ExternalParts>
</Deployment>

languages.config


<Languages>
  <Language names="IronPython,Python,py"
    languageContext="IronPython.Runtime.PythonContext"
    extensions=".py"
    assemblies="IronPython.dll;IronPython.Modules.dll"
    external="IronPython.zip"/>
</Languages>

Now create all three .zip files and add them intochildwindow folder.

To test the application with Chiron, run


C:\IronPython-2.6.1\Silverlight\bin\Chiron.exe /e: /d:childwindow

The /e:switch is important - it tells Chiron to not put any assembly into generated.xapfile. Check the application on http://localhost:2060/index.html.

To generate .xap file for distribution, run:


C:\IronPython-2.6.1\Silverlight\bin\Chiron.exe /e: /d:childwindow\app /z:app.zap

If you want to use anything from external assemblies in the code, you have toadd manually reference to those assemblies. For example, if you want to add abutton that creates a new ChildWindow, you have to change you code likethis:

app.py


from System.Windows import Application
from System.Windows.Controls import UserControl

class App:
    def __init__(self):
        self.root = Application.Current.LoadRootVisual(UserControl(), "app.xaml")
        self.root.btnNewWindow.Click += self.OnClick

    def OnClick(self, sender, event):
        import clr
        clr.AddReference('System.Windows.Controls')
        from System.Windows.Controls import ChildWindow
        self.root.panel.Children.Add(ChildWindow(Content='new window'))

a = App()

app.xaml


<UserControl x:Class="System.Windows.Controls.UserControl"
  xmlns="http://schemas.microsoft.com/client/2007"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls">
  <controls:ChildWindow >
    <StackPanel x:Name="panel">
      <TextBlock Text="Text in ChildWindow"/>
      <Button x:Name="btnNewWindow" Content="New window"/>
    </StackPanel>
  </controls:ChildWindow>
</UserControl>

If you comment out the clr.AddReference line, ImportError appears. See the explanation in Jimmy's email.

You can download the example here but note the.zip files do not contain and .dlls.

Silverlight validation with IronPython

2010-05-12T10:53:00.006+02:00

Validation support in Silverlight is done via VisualState Manager. All invalid fields have red rectangle around themselves.Unfortunately, this does not work out of the box in IronPython. We have to pushit a little bit.

To demonstrate how, I have created a small example. Create a Silverlight apptemplate and change app.py and app.xaml:


C:\IronPython-2.6.1\Silverlight\script\sl.bat python validation

app.py


import clrtype
import pyevent
from System.Windows import Application
from System.Windows.Controls import UserControl
from System.ComponentModel import INotifyPropertyChanged, PropertyChangedEventArgs

class ValidationClass(INotifyPropertyChanged):
    __metaclass__ = clrtype.ClrClass
    PropertyChanged = None

    def __init__(self, win):
        self.win = win
        self._text = 'text'
        self.PropertyChanged, self._propertyChangedCaller = pyevent.make_event()

    def add_PropertyChanged(self, value):
        self.PropertyChanged += value

    def remove_PropertyChanged(self, value):
        self.PropertyChanged -= value

    def OnPropertyChanged(self, propertyName):
        if self.PropertyChanged is not None:
            self._propertyChangedCaller(self, PropertyChangedEventArgs(propertyName))

    @property
    @clrtype.accepts()
    @clrtype.returns(str)
    def text(self):
        return self._text

    @text.setter
    @clrtype.accepts(str)
    @clrtype.returns()
    def text(self, value):
        if not value.startswith('text'):
            raise Exception('Value must start with text!')
        self._text = value
        self.OnPropertyChanged('text')

class App:
    def __init__(self):
        self.root = Application.Current.LoadRootVisual(UserControl(), "app.xaml")
        self.root.DataContext = ValidationClass(self.root)

App()

app.xaml


<UserControl x:Class="System.Windows.Controls.UserControl"
  xmlns="http://schemas.microsoft.com/client/2007"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <StackPanel>
    <TextBox x:Name="tbValidate1" Width="100" Height="25" 
      Text="{Binding text, Mode=TwoWay, ValidatesOnExceptions=True,
      NotifyOnValidationError=True}" />
    <TextBox Width="100" Height="25" />
    <TextBlock Text="{Binding text}" HorizontalAlignment="Center" />
  </StackPanel>
</UserControl>

When you run this application (C:\IronPython-2.6.1\Silverlight\script\server.bat/d:validation), you'll find out the validation does not work. There isno red rectangle when you enter wrong value; e.g. wrong.

Note the second empty TextBox is there so you can move focus out of thefirst one to update bound property.

For whatever reason, the invalid component is not switched into invalidstate. Could be IronPython bug, could be something else. Anyway to fix it, youhave to switch the control into invalid state manually. Add the BindingValidationError event:


from System.Windows import VisualStateManager
from System.Windows.Controls import ValidationErrorEventAction

...

class App:
    def __init__(self):
        self.root = Application.Current.LoadRootVisual(UserControl(), "app.xaml")
        self.root.DataContext = ValidationClass(self.root)
        self.root.BindingValidationError += self.OnBindingValidationError

    def OnBindingValidationError(self, sender, event):
        if event.Action == ValidationErrorEventAction.Added:
            VisualStateManager.GoToState(event.OriginalSource, 'InvalidUnfocused', True)
        else:
            VisualStateManager.GoToState(event.OriginalSource, 'Valid', True

Now when you enter wrong value into TextBox, you can see red rectanglearound the control. You also see, the bound variable has the old, correct valuetext:

You can download the whole source here.

Parsing XML with XDocument

2010-03-16T11:28:00.002+01:00

I needed to parse a XML document recently in Silverlight. Unfortunately,Silverlight does not have System.Xml.XmlDocument type so you need to useSystem.Xml.Linq.XDocument.

The following example works in Silverlight and with small change also in WPF.


# encoding: utf-8
import clr
clr.AddReferenceToFile('System.Xml.Linq.dll')
from System.Xml.Linq import XDocument, XNamespace

content = """<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:media="http://search.yahoo.com/mrss"
    xmlns:atom="http://www.w3.org/2005/Atom">
    <channel>
        <item>
            <title>This is the title</title>
            <media:description type="html"><p></p></media:description>
            <link>html/dsc00001.html</link>
            <media:thumbnail url="preview/dsc00001.jpg"/>
            <media:content url="web/dsc00001.jpg"/>
        </item>
        <item>
            <title></title>
            <media:description type="html"><p></p></media:description>
            <link>html/dsc00002.html</link>
            <media:thumbnail url="preview/dsc00002.jpg"/>
            <media:content url="web/dsc00002.jpg"/>
        </item>
    </channel>
</rss>"""

xDoc = XDocument().Parse(content)
namespace = XNamespace.Get("http://search.yahoo.com/mrss")
for item in xDoc.Element('rss').Element('channel').Elements('item'):
    print item.Element('title').Value
    print item.Element(namespace+'thumbnail').Attribute('url').Value

Here is the output:


This is the title
preview/dsc00001.jpg

preview/dsc00002.jpg

You have to have System.Xml.Linq.dll fromSilverlight SDK next to your app.py.

The change for WPF:


clr.AddReference('System.Xml.Linq')

Also make sure you don't have Silverlight's System.Xml.Linq.dll next to your script.

Disk Encryption in OpenWrt

2010-02-23T17:21:00.003+01:00

I have an external USB disk connected to my Asus WL-500gP which runsOpenWrt KAMIKAZE (8.09.1, r16278).

I want to have the disk encrypted. So I installed every possible packagethat has aes or loop in name but I still got the following errormessage:


root@OpenWrt:~# losetup -e aes /dev/loop/0 /dev/scsi/host0/bus0/target0/lun0/part1
Password:
ioctl: LOOP_SET_STATUS: Invalid argument

The solution was easy - install losetup that supports aes encryption.You can find the package on http://www.roth.lu/download/openwrt-usb-raid1-loopaes/.Download it, install it and viola - it works :-)


root@OpenWrt:~# losetup -e aes /dev/loop/0 /dev/scsi/host0/bus0/target0/lun0/part1
Password:
root@OpenWrt:~# mkfs.ext2 -vm0 /dev/loop/0
mkdir /mnt/disk/
mount /dev/loop/0 /mnt/disc

To mount the disc in script use


echo password | losetup -e aes /dev/loop/0 /dev/scsi/host0/bus0/target0/lun0/part1 -p0

WinDbg for beginners

2010-01-21T12:15:00.089+01:00

A few days ago I have encountered a strange problem. When I copied IronPython.Modules.dll to my application's folder, itfreezed. Strange. It looked like a bugin IronPython for me but it wasn't. With Dino Viehland help, I have found thebug in Delphi code. Dino used WinDbg to discover what is going on in thecode. I show you it is not so hard to use it.

WinDbg is part of DebugingTolls for Windows. Download and install appropriate version for yourWindows (32 or 64 bit). And download the buggedapplication.

The IpyTest.exe is Delphi 7 application that createsthe CLR and runs function Add3 from Host.dll inside the CLR. The Add3function creates IronPython engine and returns result of adding number 3 to theinput variabl. So when you run IpyTest.exe you shouldsee


C:\IronPythonBug\Delphi>IpyTest.exe
CLRVersion = v2.0.50727
8 + 3 = 11

You may actually see it because this bug does not appear on all computers.But on mine, I see just the CLRVersion. Then the program freezes.

Let's debug the application in WinDbg:


"C:\Program Files\Debugging Tools for Windows (x86)\windbg.exe" C:\IronPythonBug\Delphi\IpyTest.exe

When WinDbg and IpyTest.exe start, you see this:

Enter the following commands:


0:000> sxe clr
0:000> sxe av
0:000> .symfix
0:000> .reload
Reloading current modules
............

If you want to know what these commands do, check the help :-) Then run thedebugger with g command. It runs for a while and thenit freezes with the following output:


0:000> g
ModLoad: 76390000 763ad000   C:\WINDOWS\system32\IMM32.DLL
ModLoad: 79000000 79046000   C:\WINDOWS\system32\mscoree.dll
ModLoad: 77f60000 77fd6000   C:\WINDOWS\system32\SHLWAPI.dll
ModLoad: 79e70000 7a400000   c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorwks.dll
ModLoad: 78130000 781cb000   C:\WINDOWS\WinSxS\x86_Microsoft.VC80.CRT_1fc8b3b9a1e18e3b_8.0.50727.3053_x-ww_b80fa8ca\MSVCR80.dll
ModLoad: 7c9c0000 7d1d7000   C:\WINDOWS\system32\shell32.dll
ModLoad: 773d0000 774d3000   C:\WINDOWS\WinSxS\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.2600.5512_x-ww_35d4ce83\comctl32.dll
ModLoad: 5d090000 5d12a000   C:\WINDOWS\system32\comctl32.dll
ModLoad: 790c0000 79bb7000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\mscorlib\6d667f19d687361886990f3ca0f49816\mscorlib.ni.dll
ModLoad: 79060000 790bb000   c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorjit.dll
ModLoad: 33200000 3322c000   Microsoft.Scripting.dll
ModLoad: 68000000 68036000   C:\WINDOWS\system32\rsaenh.dll
ModLoad: 64020000 64033000   c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorsec.dll
ModLoad: 76c30000 76c5e000   C:\WINDOWS\system32\WINTRUST.dll
ModLoad: 77a80000 77b15000   C:\WINDOWS\system32\CRYPT32.dll
ModLoad: 77b20000 77b32000   C:\WINDOWS\system32\MSASN1.dll
ModLoad: 76c90000 76cb8000   C:\WINDOWS\system32\IMAGEHLP.dll
ModLoad: 74e30000 74e9d000   C:\WINDOWS\system32\RichEd20.dll
ModLoad: 04a30000 04cf5000   C:\WINDOWS\system32\xpsp2res.dll
ModLoad: 769c0000 76a74000   C:\WINDOWS\system32\userenv.dll
ModLoad: 5b860000 5b8b5000   C:\WINDOWS\system32\netapi32.dll
ModLoad: 75e60000 75e73000   C:\WINDOWS\system32\cryptnet.dll
ModLoad: 76bf0000 76bfb000   C:\WINDOWS\system32\PSAPI.DLL
ModLoad: 722b0000 722b5000   C:\WINDOWS\system32\SensApi.dll
ModLoad: 4d4f0000 4d549000   C:\WINDOWS\system32\WINHTTP.dll
ModLoad: 76f60000 76f8c000   C:\WINDOWS\system32\WLDAP32.dll
ModLoad: 33200000 3322c000   C:\IronPythonBug\Delphi\Microsoft.Scripting.dll
ModLoad: 34700000 34860000   IronPython.dll
ModLoad: 34700000 34860000   C:\IronPythonBug\Delphi\IronPython.dll
ModLoad: 33000000 33064000   Microsoft.Scripting.Core.dll
ModLoad: 33000000 33064000   C:\IronPythonBug\Delphi\Microsoft.Scripting.Core.dll
ModLoad: 7a440000 7abc5000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System\80978a322d7dd39f0a71be1251ae395a\System.ni.dll
ModLoad: 33400000 334dc000   Microsoft.Dynamic.dll
ModLoad: 33400000 334dc000   C:\IronPythonBug\Delphi\Microsoft.Dynamic.dll
ModLoad: 73000000 73008000   Microsoft.Scripting.ExtensionAttribute.dll
ModLoad: 73000000 73008000   C:\IronPythonBug\Delphi\Microsoft.Scripting.ExtensionAttribute.dll
ModLoad: 34c10000 34c80000   IronPython.Modules.dll
ModLoad: 34c10000 34c80000   C:\IronPythonBug\Delphi\IronPython.Modules.dll
ModLoad: 64890000 64981000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Configuration\b82c00e2d24305ad6cb08556e3779b75\System.Configuration.ni.dll
ModLoad: 637a0000 63cd6000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Xml\773a9786013451d3baaeff003dc4230f\System.Xml.ni.dll
(b6c.ef0): Unknown exception - code c0000091 (first chance)

>>> many lines omitted <<<

(b6c.ef0): Unknown exception - code c0000091 (first chance)

The IpyTest.exe window contains just a text:CLRVersion = v2.0.50727. Break the debugger with Ctrl-Break. Wesee there is an unknown exception with code c0000091. Let's restart theprogram and tell WinDbg to stop on this exception with the followingcommands:


.restart
sxe c0000091
.symfix
.reload
g

Here is the output:


0:003> .restart
CommandLine: C:\IronPythonBug\Delphi\IpyTest.exe
Symbol search path is: srv*
Executable search path is: 
ModLoad: 00400000 00455000   image00400000
ModLoad: 7c900000 7c9af000   ntdll.dll
ModLoad: 7c800000 7c8f6000   C:\WINDOWS\system32\kernel32.dll
ModLoad: 7e410000 7e4a1000   C:\WINDOWS\system32\user32.dll
ModLoad: 77f10000 77f59000   C:\WINDOWS\system32\GDI32.dll
ModLoad: 77dd0000 77e6b000   C:\WINDOWS\system32\advapi32.dll
ModLoad: 77e70000 77f02000   C:\WINDOWS\system32\RPCRT4.dll
ModLoad: 77fe0000 77ff1000   C:\WINDOWS\system32\Secur32.dll
ModLoad: 77120000 771ab000   C:\WINDOWS\system32\oleaut32.dll
ModLoad: 77c10000 77c68000   C:\WINDOWS\system32\msvcrt.dll
ModLoad: 774e0000 7761d000   C:\WINDOWS\system32\ole32.dll
ModLoad: 77c00000 77c08000   C:\WINDOWS\system32\version.dll
(ea8.a14): Break instruction exception - code 80000003 (first chance)
eax=00351ec4 ebx=7ffd4000 ecx=00000004 edx=00000010 esi=00351f98 edi=00351ec4
eip=7c90120e esp=0012fb20 ebp=0012fc94 iopl=0         nv up ei pl nz na po nc
cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202
ntdll!DbgBreakPoint:
7c90120e cc              int     3
0:000> sxe c0000091
0:000> .symfix
0:000> .reload
Reloading current modules
............
0:000> g
ModLoad: 76390000 763ad000   C:\WINDOWS\system32\IMM32.DLL
ModLoad: 79000000 79046000   C:\WINDOWS\system32\mscoree.dll
ModLoad: 77f60000 77fd6000   C:\WINDOWS\system32\SHLWAPI.dll
ModLoad: 79e70000 7a400000   c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorwks.dll
ModLoad: 78130000 781cb000   C:\WINDOWS\WinSxS\x86_Microsoft.VC80.CRT_1fc8b3b9a1e18e3b_8.0.50727.3053_x-ww_b80fa8ca\MSVCR80.dll
ModLoad: 7c9c0000 7d1d7000   C:\WINDOWS\system32\shell32.dll
ModLoad: 773d0000 774d3000   C:\WINDOWS\WinSxS\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.2600.5512_x-ww_35d4ce83\comctl32.dll
ModLoad: 5d090000 5d12a000   C:\WINDOWS\system32\comctl32.dll
ModLoad: 790c0000 79bb7000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\mscorlib\6d667f19d687361886990f3ca0f49816\mscorlib.ni.dll
ModLoad: 79060000 790bb000   c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorjit.dll
ModLoad: 33200000 3322c000   Microsoft.Scripting.dll
ModLoad: 68000000 68036000   C:\WINDOWS\system32\rsaenh.dll
ModLoad: 64020000 64033000   c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\mscorsec.dll
ModLoad: 76c30000 76c5e000   C:\WINDOWS\system32\WINTRUST.dll
ModLoad: 77a80000 77b15000   C:\WINDOWS\system32\CRYPT32.dll
ModLoad: 77b20000 77b32000   C:\WINDOWS\system32\MSASN1.dll
ModLoad: 76c90000 76cb8000   C:\WINDOWS\system32\IMAGEHLP.dll
ModLoad: 74e30000 74e9d000   C:\WINDOWS\system32\RichEd20.dll
ModLoad: 04a30000 04cf5000   C:\WINDOWS\system32\xpsp2res.dll
ModLoad: 769c0000 76a74000   C:\WINDOWS\system32\userenv.dll
ModLoad: 5b860000 5b8b5000   C:\WINDOWS\system32\netapi32.dll
ModLoad: 75e60000 75e73000   C:\WINDOWS\system32\cryptnet.dll
ModLoad: 76bf0000 76bfb000   C:\WINDOWS\system32\PSAPI.DLL
ModLoad: 722b0000 722b5000   C:\WINDOWS\system32\SensApi.dll
ModLoad: 4d4f0000 4d549000   C:\WINDOWS\system32\WINHTTP.dll
ModLoad: 76f60000 76f8c000   C:\WINDOWS\system32\WLDAP32.dll
ModLoad: 33200000 3322c000   C:\IronPythonBug\Delphi\Microsoft.Scripting.dll
ModLoad: 34700000 34860000   IronPython.dll
ModLoad: 34700000 34860000   C:\IronPythonBug\Delphi\IronPython.dll
ModLoad: 33000000 33064000   Microsoft.Scripting.Core.dll
ModLoad: 33000000 33064000   C:\IronPythonBug\Delphi\Microsoft.Scripting.Core.dll
ModLoad: 7a440000 7abc5000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System\80978a322d7dd39f0a71be1251ae395a\System.ni.dll
ModLoad: 33400000 334dc000   Microsoft.Dynamic.dll
ModLoad: 33400000 334dc000   C:\IronPythonBug\Delphi\Microsoft.Dynamic.dll
ModLoad: 73000000 73008000   Microsoft.Scripting.ExtensionAttribute.dll
ModLoad: 73000000 73008000   C:\IronPythonBug\Delphi\Microsoft.Scripting.ExtensionAttribute.dll
ModLoad: 34c10000 34c80000   IronPython.Modules.dll
ModLoad: 34c10000 34c80000   C:\IronPythonBug\Delphi\IronPython.Modules.dll
ModLoad: 64890000 64981000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Configuration\b82c00e2d24305ad6cb08556e3779b75\System.Configuration.ni.dll
ModLoad: 637a0000 63cd6000   C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Xml\773a9786013451d3baaeff003dc4230f\System.Xml.ni.dll
(ea8.a14): Unknown exception - code c0000091 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=ffffff00 ebx=02643d64 ecx=02640010 edx=02648e3c esi=02643bd4 edi=02640010
eip=79098f48 esp=0012ce30 ebp=0012ce34 iopl=0         nv up ei pl nz na po nc
cs=001b  ss=0023  ds=0023  es=0023  fs=0038  gs=0000             efl=00010202
mscorjit!Compiler::FlatFPIsSameAsFloat+0xa:
79098f48 d945fc          fld     dword ptr [ebp-4]    ss:0023:0012ce30=02640010

WinDbg stopped on the exception. Nice. And what now? Analyze the exception!


0:000> !analyze -v
*******************************************************************************
*                                                                             *
*                        Exception Analysis                                   *
*                                                                             *
*******************************************************************************

*** WARNING: Unable to verify checksum for C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\mscorlib\6d667f19d687361886990f3ca0f49816\mscorlib.ni.dll
*** WARNING: Unable to verify checksum for image00400000
*** ERROR: Module load completed but symbols could not be loaded for image00400000
*** ERROR: Module load completed but symbols could not be loaded for C:\WINDOWS\system32\xpsp2res.dll
*** ERROR: Module load completed but symbols could not be loaded for C:\IronPythonBug\Delphi\Microsoft.Scripting.Core.dll
*** ERROR: Module load completed but symbols could not be loaded for C:\IronPythonBug\Delphi\Microsoft.Scripting.dll
*** ERROR: Module load completed but symbols could not be loaded for C:\IronPythonBug\Delphi\Microsoft.Dynamic.dll
*** ERROR: Module load completed but symbols could not be loaded for C:\IronPythonBug\Delphi\IronPython.dll
*** ERROR: Module load completed but symbols could not be loaded for C:\IronPythonBug\Delphi\IronPython.Modules.dll
*** WARNING: Unable to verify checksum for C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Xml\773a9786013451d3baaeff003dc4230f\System.Xml.ni.dll
*** WARNING: Unable to verify checksum for C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System.Configuration\b82c00e2d24305ad6cb08556e3779b75\System.Configuration.ni.dll
*** ERROR: Module load completed but symbols could not be loaded for C:\IronPythonBug\Delphi\Microsoft.Scripting.ExtensionAttribute.dll
*** WARNING: Unable to verify checksum for C:\WINDOWS\assembly\NativeImages_v2.0.50727_32\System\80978a322d7dd39f0a71be1251ae395a\System.ni.dll
*************************************************************************
***                                                                   ***
***                                                                   ***
***    Your debugger is not using the correct symbols                 ***
***                                                                   ***
***    In order for this command to work properly, your symbol path   ***
***    must point to .pdb files that have full type information.      ***
***                                                                   ***
***    Certain .pdb files (such as the public OS symbols) do not      ***
***    contain the required information.  Contact the group that      ***
***    provided you with these symbols if you need this command to    ***
***    work.                                                          ***
***                                                                   ***
***    Type referenced: kernel32!pNlsUserInfo                         ***
***                                                                   ***
*************************************************************************
*************************************************************************
***                                                                   ***
***                                                                   ***
***    Your debugger is not using the correct symbols                 ***
***                                                                   ***
***    In order for this command to work properly, your symbol path   ***
***    must point to .pdb files that have full type information.      ***
***                                                                   ***
***    Certain .pdb files (such as the public OS symbols) do not      ***
***    contain the required information.  Contact the group that      ***
***    provided you with these symbols if you need this command to    ***
***    work.                                                          ***
***                                                                   ***
***    Type referenced: kernel32!pNlsUserInfo                         ***
***                                                                   ***
*************************************************************************

FAULTING_IP: 
mscorjit!Compiler::FlatFPIsSameAsFloat+7
79098f45 d95dfc          fstp    dword ptr [ebp-4]

EXCEPTION_RECORD:  ffffffff -- (.exr 0xffffffffffffffff)
ExceptionAddress: 79098f45 (mscorjit!Compiler::FlatFPIsSameAsFloat+0x00000007)
   ExceptionCode: c0000091
  ExceptionFlags: 00000000
NumberParameters: 1
   Parameter[0]: 00000000

FAULTING_THREAD:  00000a14

DEFAULT_BUCKET_ID:  WRONG_SYMBOLS

PROCESS_NAME:  image00400000

ERROR_CODE: (NTSTATUS) 0xc0000091 - {EXCEPTION}  Floating-point overflow.

EXCEPTION_CODE: (NTSTATUS) 0xc0000091 - {EXCEPTION}  Floating-point overflow.

EXCEPTION_PARAMETER1:  00000000

NTGLOBALFLAG:  2000000

APPLICATION_VERIFIER_FLAGS:  0

MANAGED_STACK: 
(TransitionMU)
0012E0F8 02657F5C IronPython!IronPython.Runtime.PythonContext.InitializeSystemState()+0xec
0012E108 026532E7 IronPython!IronPython.Runtime.PythonContext..ctor(Microsoft.Scripting.Runtime.ScriptDomainManager, System.Collections.Generic.IDictionary`2)+0x247
(TransitionUM)
(TransitionMU)
0012E60C 792EF7C0 mscorlib_ni!System.RuntimeMethodHandle.InvokeConstructor(System.Object[], System.SignatureStruct, System.RuntimeTypeHandle)+0x10
0012E640 792EF55A mscorlib_ni!System.Reflection.RuntimeConstructorInfo.Invoke(System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo)+0xfa
0012E6D0 79288D96 mscorlib_ni!System.RuntimeType.CreateInstanceImpl(System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])+0x3e6
0012E730 79280E10 mscorlib_ni!System.Activator.CreateInstance(System.Type, System.Reflection.BindingFlags, System.Reflection.Binder, System.Object[], System.Globalization.CultureInfo, System.Object[])+0x70
0012E754 02652BA1 Microsoft_Scripting!Microsoft.Scripting.Runtime.LanguageConfiguration.LoadLanguageContext(Microsoft.Scripting.Runtime.ScriptDomainManager, Boolean ByRef)+0x
LAST_CONTROL_TRANSFER:  from 790a40fa to 79098f48

PRIMARY_PROBLEM_CLASS:  WRONG_SYMBOLS

BUGCHECK_STR:  APPLICATION_FAULT_WRONG_SYMBOLS

STACK_TEXT:  
79098f45 mscorjit!Compiler::FlatFPIsSameAsFloat+0x7


FOLLOWUP_IP: 
mscorjit!Compiler::FlatFPIsSameAsFloat+7
79098f45 d95dfc          fstp    dword ptr [ebp-4]

SYMBOL_STACK_INDEX:  0

SYMBOL_NAME:  mscorjit!Compiler::FlatFPIsSameAsFloat+7

FOLLOWUP_NAME:  MachineOwner

MODULE_NAME: mscorjit

IMAGE_NAME:  mscorjit.dll

DEBUG_FLR_IMAGE_TIMESTAMP:  492b8341

STACK_COMMAND:  dds 79098f45 ; kb

FAILURE_BUCKET_ID:  WRONG_SYMBOLS_c0000091_mscorjit.dll!Compiler::FlatFPIsSameAsFloat

BUCKET_ID:  APPLICATION_FAULT_WRONG_SYMBOLS_mscorjit!Compiler::FlatFPIsSameAsFloat+7

Followup: MachineOwner
---------

Floating-point overflow in Delphi when working with foreign .dlls?Ask uncle Google about it and after a while you find something like this.Or, as in my case, Dino sends you the direct link :-)

Another useful commands:


.loadby sos mscorwks
!clrstack -a
!DumpStackObjects
!dumpobj 07d996fc
.load C:\Program Files (x86)\Microsoft Silverlight\3.0.40818.0\sos.dll
.load C:\Windows\Microsoft.NET\Framework\v2.0.50727\SOS.dll
.sympath SRV*c:\dos\DebugSymbols*http://msdl.microsoft.com/download/symbols

To recap it:

If you have a problem with your program, run it in WinDbg and !analyze -v it. WinDbg tells you a lot of usefulinformation which you can utilize and find a solution for your problem.

WCF Service in pure IronPython with config file

2009-11-22T20:28:00.028+01:00

I was wrong when I wrote in the lastpost that the IronPython service cannot be saved into an assembly. It can.Which opens a way to use .config file to configure the service.

This is a simple config file for the service:

ConfigService.exe.config


<?xml version="1.0"?>
<configuration>
<system.serviceModel>
    <services>
      <service name="ConfigService.myService">
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:9000/myWcfService"/>
          </baseAddresses>
        </host>
        <endpoint address=""
            binding="basicHttpBinding"
            contract="TestServiceInterface.ImyService"/>
      </service>
    </services>
  </system.serviceModel>
</configuration>

The interfaceis the same as in the previous version. The only difference in the service tothe previous version is in the ServiceHostinitialization - we omit the service configuration parameters because they arein the .config file. I also changed the clr namespace:

ConfigService.py


import clr
import clrtype
clr.AddReference('System.ServiceModel')
from TestServiceInterface import ImyService
from System import Console, Uri
from System.ServiceModel import (ServiceHost,
        BasicHttpBinding, ServiceBehaviorAttribute,
        InstanceContextMode)

class myService(ImyService):
    __metaclass__ = clrtype.ClrClass
    _clrnamespace = "ConfigService"
    _clrclassattribs = [ServiceBehaviorAttribute]

    def GetData(self, value):
        return "IronPython config service: You entered: %s" % value

sh = ServiceHost(myService)
sh.Open()
Console.WriteLine("Press  to terminate\n")
Console.ReadLine()
sh.Close()

If you want to run this script, you must save the ConfigService.exe.configas ipy.exe.config to the folder with the IronPythoninterpreter ipy.exe.

To save the service as an assembly, run the following command:


C:\IronPython-2.6\ipy.exe C:\IronPython-2.6\Tools\Scripts\pyc.py  /out:ConfigService /target:exe /main:ConfigService.py clrtype.py TestServiceInterface.py

The ConfigService.dll and ConfigService.exe are created. Add the ConfigService.exe.configto the same folder and when you run ConfigService.exe,the service starts. Note you also need all IronPython .dlls in the samefolder.

You can adjust the .config file to expose a MEX endpoint (ConfigService.mex.exe.config)but I don't see a big point in it because svcutil.exe generates C# or VB code.Anyway - here are the generated files: myService.cs, myService.config

You can run the old TestClient.py and it willsuccessfully retrieve value from the service. But the old TestClient.py does not use .config file. If we want touse .config file for the client, we have to rewrite the WCF client.First, here is the sample client .config file:

ConfigClient.exe.config


<?xml version="1.0"?>
<configuration>
  <system.serviceModel>
    <client>
        <endpoint address="http://localhost:9000/myWcfService"
            binding="basicHttpBinding"
            contract="TestServiceInterface.ImyService"/>
    </client>
  </system.serviceModel>
</configuration>

You can see it is very similar to the generated one. Wedo not specify details of the binding but we specify full name of the contractinterface.

If you check the generated client proxyclass by svcutil.exe, you see it is based on System.ServiceModel.ClientBase and the interface ImyService. There are some empty constructors and all methodsfrom ImyService interface return result of the samemethod name call on Channel property. That's why I havecreated WcfClient helper function. The client sourcethen looks like the following:

ConfigService.py


import clr
clr.AddReference('System.ServiceModel')
import System.ServiceModel
from TestServiceInterface import ImyService

def WcfClient(interface):

    class WcfClientBase(System.ServiceModel.ClientBase[interface]):

        def __getattr__(self, name):
            # if name is method from interface, return the Channel method
            if name in (k[0] for k in interface.emitted_methods.keys()):
                return getattr(self.Channel, name)

    return WcfClientBase()

wcfcli = WcfClient(ImyService)
print "WCF config client returned:\n%s" % wcfcli.GetData(11)

The WcfClient helper function returns an instance ofclass based on System.ServiceModel.ClientBase. The__getattr__ checks if the requested attribute name isinterface method and if so, it returns the Channel's method with the same name.Which is the same behavior as the generated client proxy class in couple oflines of code.

To save the client as an assembly, run the following command:


C:\IronPython-2.6\ipy.exe C:\IronPython-2.6\Tools\Scripts\pyc.py /out:ConfigClient /target:exe /main:ConfigClient.py clrtype.py TestServiceInterface.py

The ConfigClient.dll and ConfigClient.exe are created. Add the ConfigClient.exe.configto the same folder and when you run ConfigClient.exe,the client calls the service.

Having this I think there is only a small step to use the IronPython WCFservices in IIS. Unfortunately, I do not know how to do it...

WCF Service in pure IronPython

2009-11-17T13:07:00.006+01:00

I wrote about implementing WCF service in IronPython acouple of weeks ago. Meanwhile I pushed Shri a little bit with the clrtype.py and he hasimplemented ClrInterface metaclass there so we cancreate the whole WCF service in IronPython now.

The IronPython interface implementation is straightforward:

TestServiceInterface.py


import clr
import clrtype
clr.AddReference('System.ServiceModel')
from System.ServiceModel import (
        ServiceContractAttribute,
        OperationContractAttribute)
OperationContract = clrtype.attribute(
        OperationContractAttribute)

class ImyService(object):
    __metaclass__ = clrtype.ClrInterface
    _clrnamespace = "TestServiceInterface"
    _clrclassattribs = [ServiceContractAttribute]

    @OperationContract()
    @clrtype.accepts(int)
    @clrtype.returns(str)
    def GetData(self, value):
        raise RuntimeError("this should not get called")

Also switching from C# interface to IronPython interface is easy:

TestService.py


import clr
import clrtype
clr.AddReference('System.ServiceModel')
from TestServiceInterface import ImyService
from System import Console, Uri
from System.ServiceModel import (ServiceHost,
        BasicHttpBinding, ServiceBehaviorAttribute,
        InstanceContextMode)

class myService(ImyService):
    __metaclass__ = clrtype.ClrClass
    _clrnamespace = "myWcfService"
    _clrclassattribs = [ServiceBehaviorAttribute]

    def GetData(self, value):
        return "IronPython: You entered: %s" % value

sh = ServiceHost(myService, Uri(
        "http://localhost:9000/myWcfService"))
sh.AddServiceEndpoint(clr.GetClrType(ImyService),
        BasicHttpBinding(), "")
sh.Open()
Console.WriteLine("Press  to terminate\n")
Console.ReadLine()
sh.Close()

Notice that we call ServiceHost with myService which is the type and not the instance of ourservice. Because of this, the ServiceBehavior attributedoes not need to have InstanceContextMode.Single parameter.

Finally, here is the test client:

TestClient.py


import clr
clr.AddReference('System.ServiceModel')
import System.ServiceModel
from TestServiceInterface import ImyService

mycf = System.ServiceModel.ChannelFactory[ImyService](
        System.ServiceModel.BasicHttpBinding(),
        System.ServiceModel.EndpointAddress(
            "http://localhost:9000/myWcfService"))
wcfcli = mycf.CreateChannel()
print "WCF service returned:\n%s" % wcfcli.GetData(11)

The disadvantage of having just a single service instance is gone,~~the harder configuration remains~~. One new disadvantage can be~~it is not possible (yet) to compile the interface and save it todisk~~ nor use it from other .NET languages.

Edit 22. 11. 2009: See WCFService in pure IronPython with config file

INotifyPropertyChanged and databinding in Silverlight

2009-11-16T11:14:00.008+01:00

In the previousarticle, I wrote about IronPython and databinding in WPF applications. Thelast note was it does not work in Silverlight. Thanks to Shri Borde(IronPython/IronRuby dev lead) who updated clrtype module, thenote is not true any more.

Let's create a small Silverlight app in IronPython from scratch. I useIronPython 2.6 RC2. Follow http://lists.ironpython.com/pipermail/users-ironpython.com/2009-October/011543.htmlto avoid bugs in IronPython 2.6 RC2.

Create a new project:


C:\IronPython-2.6\Silverlight\script\sl.bat python BindTest

Change the app.xaml to


<usercontrol x:Class="System.Windows.Controls.UserControl"
    xmlns="http://schemas.microsoft.com/client/2007"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <stackpanel x:Name="DataPanel"
        Orientation="Horizontal">
        <textblock Text="Size"/>
        <textblock Text="{Binding size}"/>
        <textbox x:Name="tbSize"
            Text="{Binding size, Mode=TwoWay}" />
        <button x:Name="Button"
            Content="Set Initial Value"></Button>
    </StackPanel>
</UserControl>

The difference comparing to WPFversion is we have to specify binding mode because the default mode forTextBox in Silverlight is OneWay. And we cannot use UpdateSourceTrigger=PropertyChanged because Silverlight does not havesuch UpdateSourceTrigger.

Silverlight binding is limited comparing to WPF. That's why we have tocreate CLR properties to Silverlight be able to see them. DevHawk has anice serie about clr types on his blog.

Creating CLR property with clrtype.py is easy.Shri described it on IronPython mailinglist. Because I use my enhanced @notify_propertydecorator, I can write:


class ViewModel(NotifyPropertyChangedBase):
    __metaclass__ = clrtype.ClrClass
    _clrnamespace = "BindTest"
    
    def __init__(self):
        super(ViewModel, self).__init__()
        # must be string to two-way binding work
        # correctly
        self.size = '10'

    @notify_property
    @clrtype.returns(str)
    def size(self):
        return self._size

    @size.setter
    @clrtype.accepts(str)
    def size(self, value):
        self._size = value
        print 'Size changed to %r' % self.size

The NotifyPropertyChangedBase class is the same asfor WPFversion. The enhanced @notify_property decoratorcalls automatically clrtype.accepts() for getter andclrtype.returns() for setter so we do not need to callthem manually for every property:


class notify_property(property):

    def __init__(self, getter):
        def newgetter(slf):
            #return None when the property does not
            # exist yet
            try:
                return getter(slf)
            except AttributeError:
                return None
        getter = clrtype.accepts()(getter)
        clrtype.propagate_attributes(getter, newgetter)
        super(notify_property, self).__init__(newgetter)

    def setter(self, setter):
        def newsetter(slf, newvalue):
            # do not change value if the new value is
            # the same, trigger PropertyChanged event
            # when value changes
            oldvalue = self.fget(slf)
            if oldvalue != newvalue:
                setter(slf, newvalue)
                slf.OnPropertyChanged(setter.__name__)
        setter = clrtype.returns()(setter)
        clrtype.propagate_attributes(setter, newsetter)
        return property(
            fget=self.fget,
            fset=newsetter,
            fdel=self.fdel,
            doc=self.__doc__)

Then App looks similarly to the WPFcounterpart:


class App:
    def __init__(self):
        self._vm = ViewModel()
        self.root = Application.Current.LoadRootVisual(
                UserControl(), "app.xaml")
        self.DataPanel.DataContext = self._vm
        self.Button.Click += self.OnClick

    def OnClick(self, sender, event):
        # must be string to two-way binding work
        # correctly
        self._vm.size = '10'

    def __getattr__(self, name):
        # provides easy access to XAML elements
        # (e.g. self.Button)
        return self.root.FindName(name)

a = App()

Run Chiron with the BindTest app


C:\IronPython-2.6\Silverlight\script\sl.bat python BindTest

and check the application in the browser on http://localhost:2060/index.html.

Whatever you write into the text box appears in the label in front of thetext box when the text box loses the focus. When you click the button, thevalue is reseted. You can also change the value from the console:


a._vm.size= '3'

Download app.xamland app.py. You alsoneed clrtype.py andpyevent.py (from C:\IronPython-2.6\Tutorial\pyevent.py) in the BindTestfolder.

INotifyPropertyChanged and databinding in IronPython WPF

2009-11-11T12:22:00.029+01:00

INotifyPropertyChangedis important interface for building WPF or Silverlight applications using M-V-VM concept (MSDNarticle).

In simple language, you have a Model which provides access to yourdata (e.g in database, files, web, etc.). Then you have a ViewModel thataccess data in the Model via Model's interface and provides data to aView which is XAML file with UI layout. Linkage between ViewModel andView is done by binding that utilizes PropertyChanged event to properlyupdate all UI elements.

I have found two examples how to implement INotifyPropertyChangedinterface in IronPython. Thefirst one uses __setattr__ hook. Personally, I don't like it - it is notclear and easily readable code. Thesecond one is better because it uses properties. But you have to writeself.OnPropertyChanged("my_property_name") for everyproperty. Not ideal.

That's why I sit down and write a notify_property:


class notify_property(property):

    def __init__(self, getter):
        def newgetter(slf):
            try:
                return getter(slf)
            except AttributeError:
                return None
        super(notify_property, self).__init__(newgetter)

    def setter(self, setter):
        def newsetter(slf, newvalue):
            oldvalue = self.fget(slf)
            if oldvalue != newvalue:
                setter(slf, newvalue)
                slf.OnPropertyChanged(setter.__name__)
        return property(
            fget=self.fget,
            fset=newsetter,
            fdel=self.fdel,
            doc=self.__doc__)

With this subclass I aimed several goals:

usage simple as @property decorator (actualy no other usage is possible as I implemented __init__ with just one parameter that must be the getter)
when property is on yet defined, it should return None
automaticaly handle PropertyChanged event when and only when property has changed

We also need to implement INotifyPropertyChanged interface inIronPython so we can call OnPropertyChanged method. See Overidingevents in IronPython\Doc\dotnet-integration.rst tounderstand what means add_ and remove_ methods.


class NotifyPropertyChangedBase(INotifyPropertyChanged):
    PropertyChanged = None

    def __init__(self):
        self.PropertyChanged, self._propertyChangedCaller = pyevent.make_event()

    def add_PropertyChanged(self, value):
        self.PropertyChanged += value

    def remove_PropertyChanged(self, value):
        self.PropertyChanged -= value

    def OnPropertyChanged(self, propertyName):
        if self.PropertyChanged is not None:
            self._propertyChangedCaller(self, PropertyChangedEventArgs(propertyName))

Now we can implement a simple class with properties with changenotification:


class DataObject(NotifyPropertyChangedBase):
    
    def __init__(self, size):
        super(DataObject, self).__init__()
        self.size = size

    @notify_property
    def size(self):
        return self._size

    @size.setter
    def size(self, value):
        self._size = value

You can see it is very easy - just like any other property in Python.

Finaly, let's put all together. When you run the code below, it shows awindow with label, textbox and button. The label is updated as you type intothe textbox and a message is written into the console as well. By default, thetextbox is updated when it looses focus, so I have to change UpdateSourceTrigger to PropertyChanged. When you clickthe button, the value is reset. Note if you use type int instead of string the two-waybindign would not work.

notpropwpf.py


import clr
import System
clr.AddReference('PresentationFramework')
clr.AddReference('PresentationCore')

from System.Windows.Markup import XamlReader
from System.Windows import Application, Window
from System.ComponentModel import INotifyPropertyChanged, PropertyChangedEventArgs
import pyevent

XAML_str = """<window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Width="250" Height="62">
    <stackpanel x:Name="DataPanel" Orientation="Horizontal">
        <label Content="Size"/>
        <label Content="{Binding size}"/>
        <textbox x:Name="tbSize" Text="{Binding size, UpdateSourceTrigger=PropertyChanged}" />
        <button x:Name="Button" Content="Set Initial Value"></Button>
    </StackPanel>
</Window>"""

class notify_property(property):

    def __init__(self, getter):
        def newgetter(slf):
            #return None when the property does not exist yet
            try:
                return getter(slf)
            except AttributeError:
                return None
        super(notify_property, self).__init__(newgetter)

    def setter(self, setter):
        def newsetter(slf, newvalue):
            # do not change value if the new value is the same
            # trigger PropertyChanged event when value changes
            oldvalue = self.fget(slf)
            if oldvalue != newvalue:
                setter(slf, newvalue)
                slf.OnPropertyChanged(setter.__name__)
        return property(
            fget=self.fget,
            fset=newsetter,
            fdel=self.fdel,
            doc=self.__doc__)

class NotifyPropertyChangedBase(INotifyPropertyChanged):
    PropertyChanged = None

    def __init__(self):
        self.PropertyChanged, self._propertyChangedCaller = pyevent.make_event()

    def add_PropertyChanged(self, value):
        self.PropertyChanged += value

    def remove_PropertyChanged(self, value):
        self.PropertyChanged -= value

    def OnPropertyChanged(self, propertyName):
        if self.PropertyChanged is not None:
            self._propertyChangedCaller(self, PropertyChangedEventArgs(propertyName))

class ViewModel(NotifyPropertyChangedBase):
    
    def __init__(self):
        super(ViewModel, self).__init__()
        # must be string to two-way binding work correctly
        self.size = '10'

    @notify_property
    def size(self):
        return self._size

    @size.setter
    def size(self, value):
        self._size = value
        print 'Size changed to %r' % self.size

class TestWPF(object):

    def __init__(self):
        self._vm = ViewModel()
        self.root = XamlReader.Parse(XAML_str)
        self.DataPanel.DataContext = self._vm
        self.Button.Click += self.OnClick
        
    def OnClick(self, sender, event):
        # must be string to two-way binding work correctly
        self._vm.size = '10'

    def __getattr__(self, name):
        # provides easy access to XAML elements (e.g. self.Button)
        return self.root.FindName(name)

tw = TestWPF()
app = Application()
app.Run(tw.root)

You need pyevent.py from IronPython\Tutorial\ folder to run to example.

~~Unfortunately, this does not work in Silverlight, probably becausethe property is not .NET field~~. See nextatricle for Silverlight version.

WCF Service in IronPython

2009-10-30T18:08:00.015+01:00

Edit 17. 11. 2009: See the article about WCFservice in pure IronPython.

Until IronPython 2.6, it was not possible to create WCF service host in pureIronPython. The closest way was to create stub in C# and subclassit in IronPython or create the whole service in C# and runit from IronPython. It is now much simpler with IronPython 2.6 although youstill have to write a little C# code.

Simple WCF service implemented in C# looks like this:

TestServiceInterface.cs


using System;
using System.ServiceModel;

namespace TestServiceInterface
{
    [ServiceContract]
    public interface ImyService
    {
        [OperationContract]
        string GetData(int value);
    }
}

TestService.cs


using System;
using System.ServiceModel;
using TestServiceInterface;

namespace myWcfService
{
    public class myService : ImyService
    {
        public string GetData(int value)
        {
            return string.Format("You entered: {0}", value);
        }
    }

    public class mySvc
    {
        public static void Main()
        {
            ServiceHost sh = new ServiceHost(
                typeof(myService),
                new Uri("http://localhost:9000/myWcfService"));
            sh.AddServiceEndpoint(
                typeof(ImyService),
                new BasicHttpBinding(),
                "");
            sh.Open();
            Console.WriteLine("Press  to terminate\n");
            Console.ReadLine();
            sh.Close();
        }
    }
}

You build it:


csc /target:library TestServiceInterface.cs
csc /r:TestServiceInterface.dll TestService.cs

The reason I put TestServiceInterface into separate file is that youcannot create interfaces in IronPython. So this is the only part written in C#when implementig WCF service in IronPython.

The implementation then looks like this:

TestService.py


import clr
import clrtype
clr.AddReference('System.ServiceModel')
clr.AddReference('TestServiceInterface')
from TestServiceInterface import ImyService
from System import Console, Uri
from System.ServiceModel import (ServiceHost, BasicHttpBinding,
        ServiceBehaviorAttribute, InstanceContextMode)
ServiceBehavior = clrtype.attribute(ServiceBehaviorAttribute)

class myService(ImyService):
    __metaclass__ = clrtype.ClrMetaclass
    _clrnamespace = "myWcfService"
    _clrclassattribs = [
            ServiceBehavior(InstanceContextMode=InstanceContextMode.Single)]

    def GetData(self, value):
        return "IronPython: You entered: %s" % value

sh = ServiceHost(
        myService(),
        Uri("http://localhost:9000/myWcfService")
    )
sh.AddServiceEndpoint(
        clr.GetClrType(ImyService),
        BasicHttpBinding(),
        "")
sh.Open()
Console.WriteLine("Press  to terminate\n")
Console.ReadLine()
sh.Close()

The myService class must haveInstanceContextMode.Single ServiceBehavior attribute because we arepassing service instance to the ServiceHostconstructor. This is done via new __clrtype__metaclass. See the errorif we don't use the attribute. I was not able to pass type into theServiceHost constructor.

To test the service, you can use C# or IronPython client implementation:

TestClient.cs


using System;
using System.ServiceModel;
using TestServiceInterface;

namespace myWcfClient
{
    public class cli
    {
        public static void Main()
        {
   ChannelFactory mycf = new ChannelFactory(
     new BasicHttpBinding(),
        new EndpointAddress("http://localhost:9000/myWcfService"));
   ImyService wcfcli = mycf.CreateChannel();
   Console.WriteLine("Calling GetData(33) returns:\n{0}", wcfcli.GetData(33));
        }
    }
}

TestClient.py


import clr
clr.AddReference('System.ServiceModel')
import System.ServiceModel
clr.AddReference('TestServiceInterface')
from TestServiceInterface import ImyService

mycf = System.ServiceModel.ChannelFactory[ImyService](
        System.ServiceModel.BasicHttpBinding(),
        System.ServiceModel.EndpointAddress("http://localhost:9000/myWcfService"))
wcfcli = mycf.CreateChannel()
print "WCF service returned:\n%s" % wcfcli.GetData(11)

Disadvantages:

You can have only single instance of the service because you are passing the service instance instead of service type.
You cannot easily use .config file to configure your service.

How to clone VirtualBox virtual machine

2009-09-24T23:53:00.015+02:00

VirtualBox is great piece ofsoftware for virtualization. I like it more than VMWare or VirtualPC. The downsideof it is its lack of easy cloning or copying capabilities. There arenone. And because everything in VirtualBox has UUID (guid), pure file copy doesnot work well.

All advices I have seen were about: create the new virtual machinemanually, clone HDD .vdi file with VBoxManageclonevdi command and attach it to the newly created virtualmachine. Manually!?

That's why I've created a simple Python script that cares about exportingand importing virtual machines (Thanks for the VirtualBox 3 SDK!). Whenexporting, you can select the virtual machine and snapshot you wantto export:

The exported machines are stored in exp folder atthe script file. The time stamp is added to the machine name forunique identification. When importing, you are offered with the savedvirtual machines and you simply choose one. Of course you can copy the exportedmachine to different computer (having the same VirtualBox versions isrecommended).

The script is very simple and targeted to my needs. That means it exportsonly primary HDD and network adapter 0. It does not export CD/DVD-ROM, Floppynor Serial ports.

Try it and let me know whether it's helpful: downloadscript (it requires ConfigObj 4).

Update 1. 10. 2009: I struggled running the script on my new Win7 64-bit system. It complained class is not registered for VirtualBox.Session.The reason was mixing 32-bit and 64-bit programs - see the explanation.If you use 64-bit OS, you have to have installed 64-bit version of Pythonand pywin32!

Update 11. 11. 2009: I have updated the script to better serve myneeds. For example, when restoring virtual machine, you can enter a new namefor it. Be carefull when restoring one saved machine to two new ones as youhave to chagne MAC address manually.

Unfortunately, the old config file is not compactible with the new version.But I think you can guess from the Python exception what is wrong with theconfig file and fix it. The old version is still available.

Update 29. 12. 2009: When I upgraded to VirtualBox 3.1, Ireceived KeyError when I run my script({2158464A-F706-414B-A8C4-FB589DFC6B62}). To get rid of it, delete all fromfrom \Python26\Lib\site-packages\win32com\gen_py\ except __init__.py.

Pycon 2009: Functional Testing of Desktop Applications

2009-05-16T18:26:00.003+02:00

Here is a link to Michael Foord talk at Pycon 2009 in Chicago about functional testing of desktop applications:

Functional Testing of Desktop Applications
Many advocates of unit testing believe that testing desktop (GUI) applications is so difficult as to not be worth it. Not only is it possible, but 'functional testing' (testing an application from the point of view of the user) is an important part of an agile development process.

I watched it yesterday and it is very good!

Testing an unknown application

2009-05-15T17:25:00.004+02:00

From time to time you may need to test an unknown application. I haveencounter it when I needed to test our installation program. The task wassimple - install the application for automated smoke tests. In such cases Igladly return to Accessibility.

Let's pretend our testing application is not written in .NET and the onlyway how to explore it is through the accessibility (AccExplorer):

All we need to do is to access Accessibility objects from IronPython. Thereis a project called Managed WindowsAPI that nicely wraps accessibility for .NET. It also wraps other Win32 APIcalls (mouse clicks etc.) but I stay with Win32API.dllbecause of my laziness :-).

Utilizing the Managed Windows APIyou can control the accessibility objects. Here is the snippet:


import clr
# Win32API provide access to Win32 API functions
clr.AddReference('Win32API')
from Win32API import Win32API
# ManagedWinapi provide access to Accessibility objects
clr.AddReference('ManagedWinapi')
import ManagedWinapi.Accessibility as ma
import ManagedWinapi.Windows as mw

def GetGUIATWindow():
   """ Return GUIAT_PoC window accessibility object. """
   def callback(aWindow):
       return aWindow.Title == 'GUIAT - Proof of Concept'
   guiat_window = mw.SystemWindow.FilterToplevelWindows(callback)
   # assume guiat_window is list with just one object
   return ma.SystemAccessibleObject.FromWindow(guiat_window[0],
       ma.AccessibleObjectID.OBJID_WINDOW)

guiat_acc = GetGUIATWindow()
# position of the 'New listbox item' text box
pos = guiat_acc.Children[3].Children[1].Location
# focus the text box
Win32API.MouseClick(pos.X + pos.Width/2, pos.Y + pos.Height/2)
Win32API.SendString('Accessibility test')
# position of the 'Add Item' button
pos = guiat_acc.Children[3].Children[2].Location
# click the button
Win32API.MouseClick(pos.X + pos.Width/2, pos.Y + pos.Height/2)

To run it, download managedwinapi-0.3.zipand extract the ManagedWinapi.dll to the same folder as the source code.

When you run the code, it enters Accessibility test text into Newlistbox item text box and clicks Add Item button. The controls arealways on the same position within the Children enumeration so we can usedirect referencing: e.g. guiat_acc.Children[3].Children[2] is the button accessibilityobject.

Enhancing this example is up to you - I have created several functions thattake care about entering the text into text boxes, selecting buttons or achecking check boxes. That's all I need to create a script that installs ourapplication.

Building the framework (3)

2008-10-30T08:50:00.004+01:00

After a while, it's time to continue building the GUI Automated Testingframework. Today, I focus on a list box. You can download the source as usual.

I assume standard windows list box component where only unique items arestored and only one item can be selected. These two conditions are set onlybecause of simplicity of the example. If you don't like them, enhance theexample by yourself as your homework :-)

The list box componentis again a subclass of BaseComponent. It isquite simple - it has one method and two properties:

Select(self, aItem)

The method selects aItem in the list box.


def Select(self, aItem):
  """ select an item from list box
  @aItem - string with item to select
  """
  if aItem not in self.items:
    raise Exception("Item '%s' not in list box" % aItem)
  self.guiat.Activate()
  self._CheckVisibility()
  pos = self.location
  # click on the first item to focus the list box
  Win32API.MouseClick(pos[0] + (pos[2]/2), pos[1] + 3)
  # send Home to be sure we are on the first item
  # (we could be scrolled down a little)
  Win32API.SendKey(Win32API.VK_HOME)
  # simulate pressing down arrow until we find the item
  # we should find it because it is among self.items
  while self.value != aItem:
    Win32API.SendKey(Win32API.VK_DOWN)

First, it checks whether aItem is in the list box and raises anexception if not. Then it clicks onto the first visible list box item,simulates pressing Home key to focus the first item and repeatedly pressDown key until the value equals aItem.

This approach has the advantage we don't need to care about scroll box. Thebasic windows list box does not provide nice properties or methods to returnits state. We would have to dive into Win32 API to find it. For example, theDevExpress ListBoxControlhas method GetViewInfothat returns information about internal list box state.

This brings us to the important note:

We do not test the list box component. Wetest the application.

One way of selecting item in a list box is enough. Of course, we must beaware of its limitations and side effects. Selecting an item with our GUIATcomponent fires one OnClick and several OnChange events.

items

The property contains read only list of all items in the list box.

value

The property contains the selected item in the list box. User can assign astring to it to select the string in the list box.

Incorporating the new GUIAT ListBox class into theframework is easy - just add it into the RecognizableComponents dictionary of the Form class.

This is the last post about controlling components. You know the idea sodeveloping a new GUIAT class controlling your component should be easy.

Next time, I show how to control application that is already started.

GUI Testing at Resolver Systems

2008-09-26T00:55:00.010+02:00

I'm currently quite busy at work and with my other activities (like photos). That's why instead of writing another chapter of the GUI Automated Testing framework, I point you to the great article of Michael Foord:

Functional Testing of GUI Applications

Michael describes his experiences with GUI automated testing in Resolver Systems.

They use quite similar approach to run the tested application. It is run in another thread but the thread invoking is different. I am not a specialist in threading but I will try to find out more about which way is better or whether there are any catches[1].

They also do not use win32api for simulating user's input. They usually call directly the .NET method responsible for generating the requested event (e.g. PerformClick). That can be dangerous because your test can pass even when user is unable to click the button - the button could be hidden behind another component.

[1] My current problem can be caused by threading. When I run our application from automated testing tool, two buttons overlap. When I run it normally, it is OK. To be it stranger, it occurs only on my PC. I have no idea why...

Update 10/30/2008: I have not found any problem with my way of starting the tested application. I asked my co-workers, searched for articles about threading and found both ways should be similar. [1] is still mystery to me, though.

Update 8/20/2009: Mystery [1] solved - it was bug in our application :-)

Building the framework (2)

2008-08-18T00:30:00.012+02:00

Last time we have started building the GUI Automated Testing framework. Today we are going to enhance it. Download the source to be able to follow the text.

The first version implemented the BaseComponent class to represent windows components. We could not do anything but find out location of the component. It would be nice to be able write text into a text box or click a button by simple method, wouldn't it?

To do that, we need to know the type of each component. The type name of .NET components is stored in component.GetType().Name. Knowing the type, we create subclass of BaseComponent for each type. In the subclass, we provide nice methods and properties.

First, we enhance BaseComponent class. We add _CheckVisibility(self) method that checks whether the component is visible. If not, it raises an exception. We need it for checking if button is visible so we can click it or text box is visible to write it. And we add guiat property to be able to activate the tested application from a component by calling self.guiat.Activate().

Let's look on a button. The Button class is very simple:

from time import sleep
from Win32API import Win32API
from BaseComponent import BaseComponent

class Button(BaseComponent):
   """interface to the Button component"""

   def Click(self):
       """ perform left mouse click on the center of the button, no parameters"""
       self.guiat.Activate()
       self._CheckVisibility()
       pos = self.location
       Win32API.MouseClick(pos[0] + (pos[2]/2), pos[1] + (pos[3]/2))
       sleep(0.1)

The Click(self) method activates the tested application, checks whether the component is visible, finds out the position of the button, clicks into the middle of the button position, and finally waits a little bit. I do not like the waiting but it is here for safety. Windows may repainting some areas or do some other cool thinks, so it is better to give them some time for it.

The TextBox class provides three methods and one property:

FocusEditor(self)
The method essentially does the same as Button's Click method. It activates the tested application, checks whether the component is visible, and clicks into the middle of the TextBox position to focus the editor.
Clear(self)
The method focuses the text box, moves cursor to the start position simulating pressing Home key, and simulates pressing Delete key until the text in text box is empty. If the text is not empty then, it raises exception.
Write(self, aString)
The method clears the text box and uses Win32API method SendString to simulate typing aString. Then checks whether the text box contains the aString value and raises exception if not.
value
The property contains the actual value of the text box. When user assigns a string to it, the string is written to the text box.

Now look on the creating instances of GUIAT components in the Form class. We have simply added dictionary with known component types (RecognizableComponents). When we go through all components on the form in the _AnalyzeStructure method, we first check whether we know the component type or not. If so, we create instance of the appropriate component type class (e.g. Button or TextBox). If not, we create instance of the BaseComponent class.

Let's try a small example:

>>> import GUIAT
>>> g = GUIAT.GUIAT()
>>> g.Run()
Starting GUIAT...
"frmGUIAT" (frmGUIAT)
  "btnAddItem" (Button)
  "lblNewItem" (Label)
  "txtNewItem" (TextBox)
  "lbxItems" (ListBox) - UNKNOWN
  "btnQuit" (Button)
Starting GUIAT done.
>>> txt = g.mainForm._GetComponentByName('txtNewItem')
>>> btn = g.mainForm._GetComponentByName('btnAddItem')
>>> txt.value = 'Hello world!'
>>> btn.Click()

The result of the above small script is a new line in the list box. You see that the button, label, and text box are know component types. The label is treated as BaseComponent (see RecognizableComponents in Form.py). The list box is unknown component.

Today, we have shown how to create button and text box GUIAT classes that control respective .NET components. We can already script our small tested application!

Next time, we add list box class and logging.

Building the framework (1)

2008-07-29T23:28:00.004+02:00

Today we start building the automated test framework. We have prepared tools in previous parts. See them to learn how to run tested application in a separate thread or how to simulate user's input.

The foundation of our test framework are IronPython classes that control Windows components. Simply said, everything in Windows is a component. So we create IronPython layer that allows controlling each Windows component easily. Then we create classes that will control forms with many components. And finally, we build test scripts and test suites for the whole application.

We start with just three simple classes. The first class, GUIAT, is the core class taking care of running, activating (focusing), and inspecting the tested application. The second class, BaseComponent, is ancestor of all component classes. The last one, Form, descendant of BaseComponent, is ancestor of all forms.

The BaseComponent class provides access to common properties of all components. There is just one in the first version:

location - size and position of the component on the screen (not within the parent form)

The BaseComponent class has also several private variables and methods:

_name - name of the component, not all components have this field filled
_control - reference to the .NET component instance
_guiat - reference to the main GUIAT object (see below)
_guiatComponents - dictionary with all child GUIAT components
_GetComponentByName - method that searches for component with given name

Note: The .NET component means instance of the Windows component in the tested application. The GUIAT component means instance of the IronPython class that controls the .NET component.

The Form class extends the BaseComponent class. Its purpose is to find and store all components on itself. It has one private method that does it:

_AnalyzeStructure - method that searches and stores components on a form. It is recursively called for each member of the Controls collection. It prints out the name, type, and depth level of the found components. Then it creates BaseComponent instance and stores it into the _guiatComponents dictionary of the parent component.

The GUIAT class as the core class of the framework contains in the first version only one property and two methods:

mainForm - GUIAT representation of the main form of the tested application (Form instance)
Run - method that runs the tested application in separate thread and creates the Form instance of the main form
Activate - method that activates (focuses) the tested application

Let's try a small example:

>>> import GUIAT
>>> g = GUIAT.GUIAT()
>>> g.Run()
Starting GUIAT...
"frmGUIAT" (frmGUIAT)
  "btnAddItem" (Button)
  "lblNewItem" (Label)
  "txtNewItem" (TextBox)
  "lbxItems" (ListBox)
  "btnQuit" (Button)
Starting GUIAT done.
>>> print g.mainForm._GetComponentByName('txtNewItem').location
(212, 177, 96, 16)
>>> g.Activate()
True

The above code runs the tested application, lists name and type of all components, then prints location of the text box, and finally activates the tested application.

To sum up the process again:

Create instance of the GUIAT class - let's call it g
g.Run() runs the tested application
g.Run() creates instance of IronPython Form class for the main form of the tested application
The Form instance searches during its initialization all components on the main form, prints information about them, and creates BaseComponent instance for each of them
To find location of "txtNewItem" component, execute:
g.mainForm._GetComponentByName("txtNewItem").location
To activate tested application, execute:
g.Activate()

Today I presented the core of my GUI automated testing framework (source). I'm going to extend it and make it more user friendly in next parts.

Simulate user's input

2008-07-08T21:12:00.011+02:00

We have learned in the previouspart how to explore the tested application and read its values. To test it,we also need set values to its fields.

The first idea may be to utilize the .NET objects. When we can read valuesfrom the tested application fields, we can also set them. Use the code snippetfrom the previouspart to run the tested application and follow it by command


App.Controls[2].Text = 'GUIATtext'

The tested application is started and GUIATtext appears in the Newlistbox item text box.

Well, it does not appear as a proper testing to me. I'd rather simulateuser's interaction with mouse and keyboard. Unfortunately, sending key strokesand mouse events is not job for .NET framework. We have to dive deep intoWindows and use Win32 API to perform these tasks.

I have created a simple DLL to make Win32 API functions available forIronPython [1]. Moreover, I have added functions to simulate user's input. Hereis the list of functions in the Win32API namespace with a shortdescription:

GetForegroundWindow()

return handle of the active window

SetForegroundWindow(handle)

set the active window to the window with handle return boolean

ShowWindow(handle, state)

set window with handle to state (minimalized, maximalized, ...) return boolean

GetWindowText(handle, title, capacity)

return title of window with handle, title variable type is String of capacity size

MouseClick(X, Y)

simulate click with left mouse button on position X, Y

SendKey(virtual_key)

simulate pressing virtual_key

SendString(string)

simulate typing a string

I will not go into details here. Anyone interested can explore the sources of the Win32API.dll.

Using these functions is straightforward in IronPython. Just download the Win32API.dll and look at theexample below how to perform a mouse click on the specific position:


import clr
clr.AddReference('Win32API')
from Win32API import Win32API
Win32API.MouseClick(10, 10)

The code snippet moves mouse to the coordinates 10, 10 (that is to thetop-left corner of the screen) and perform a click with the left mouse button.More useful examples will follow in next parts.

Finally, couple of warnings. The simulated mouse click is caught by the topmost window on the position. And the simulated key strokes are sent to theactive window. That means we have to payattention to position and active state of the tested application.

In the next part, we start building the GUIAT testing framework.

[1] I do not know how to access Win32 API directly from IronPython.

Exploring test application: IronPython (2)

2008-06-24T21:12:00.018+02:00

We demonstrated how to run a .NET application from IronPython in the previous part. However, we couldn't control it while it was running. The solution for this problem is to run the tested application in a separate thread. Thus we will be able to enter commands in IronPython console while the tested application is running. Here is a snippet from the source:

import clr
clr.AddReference('System')
clr.AddReference("System.Windows.Forms")
from System import *
from System.Reflection import *
from System.Threading import *
from System.Windows.Forms import Application
from time import sleep

def RunMeCallBack(var):
    global App
    asm = Assembly.LoadFrom('GUIAT_PoC.exe')
    asm_type = asm.GetType('GUIAT_PoC.frmGUIAT')
    App = Activator.CreateInstance(asm_type)
    Application.Run(App)

App = None
ThreadPool.QueueUserWorkItem(WaitCallback(RunMeCallBack))
while not App:
    sleep(0.2)

The RunMeCallBack function starts the tested application the same way as we showed in the previous part. We create an independent thread and run this function in it so it does not block the console. The thread finishes its work when the tested application terminates (the main form of the application is closed) or when the console is closed.

The important part is line

App = Activator.CreateInstance(asm_type)

Here we remember the instance of the main form in the variable App. We have access to the whole application thanks to the App variable! The while cycle at the end ensures waiting until the App variable is not None. Which only happens when our tested application is up and running.

The App variable is our Holy Grail. Let's explore what is inside:

>>> App
<GUIAT_PoC.frmGUIAT object at 0x000000000000002B
[GUIAT_PoC.frmGUIAT, Text: GUIAT - Proof of Concept]>
>>> App.Text
'GUIAT - Proof of Concept'

Basically, we have access to all public properties and methods. Try dir(App) and you'll see. With a trick, we can even access private properties and methods (using the power of reflection).

To find what components are on the main form, iterate through the Controls collection:

>>> for c in App.Controls:
...   print c.Name, c.GetType()
...
btnAddItem System.Windows.Forms.Button
lblNewItem System.Windows.Forms.Label
txtNewItem System.Windows.Forms.TextBox
lbxItems System.Windows.Forms.ListBox
btnQuit System.Windows.Forms.Button

To find out what text is in the text box, try the following:

>>> App.Controls[2].Text
''

Now, write something directly into the text box in the tested application and call the statement again:

>>> App.Controls[2].Text
'something'

Cool, isn't it? ;-)

Next time, I show you how to simulate user interaction programatically - how to send a text or click to the tested application.

Exploring test application: IronPython (1)

2008-06-22T13:33:00.015+02:00

How can IronPython help with exploring the test application? The answer is .NET Reflection:

Reflection is the mechanism of discovering information solely at run time.

We can discover both class and instance information. That's important. Knowing class information, we know what the object is capable of. We know whether it is a button having click method or a text edit having value property. And knowing instance information, we can find out what text the text edit displays.

That's nice but to be able to utilize the reflection, we need access to the tested application's objects from our testing framework. That's easy. The tested application is a .NET application so we can run it directly from IronPython.

When you look to Program.cs (source), you see how the tested application is started. If you don't have the sources of tested application available, you can use Lutz Roeder's .NET Reflector to find the information.

static void Main()
{
   Application.EnableVisualStyles();
   Application.SetCompatibleTextRenderingDefault(false);
   Application.Run(new frmGUIAT());
}

Let's mimic the start in IronPython. We are not interested in the first two rows. The third row is the core. The Application class is part of System.Windows.Forms namespace. So we just need to create an instance of frmGUIAT class. To create it, we use method CreateInstance of Activator class from System namespace. The CreateInstance method needs to know the type of the future instance. We find the type utilizing the reflection.

The whole code looks like this:

import clr
clr.AddReference('System')
clr.AddReference("System.Windows.Forms")
from System import *
from System.Reflection import *
from System.Windows.Forms import Application

asm = Assembly.LoadFrom('GUIAT_PoC.exe')
asm_type = asm.GetType('GUIAT_PoC.frmGUIAT')
App = Activator.CreateInstance(asm_type)
Application.Run(App)

When you run the above code from IronPython console, the tested application is displayed. Note the IronPython must be started form the directiory where GUIAT_PoC.exe is located. The disadvantage is we cannot do anything in IronPython console while the tested application is running. The solution is to run it in separate thread. I will show it in the next article.

Exploring test application: Accessibility

2008-06-12T23:50:00.002+02:00

Accessibility looks more promising:

Active Accessibility (AA) is technology developed by Microsoft to make the Windows platform more accessible to people with disabilities. It consists of a set of COM interfaces and methods which allow an application to expose information to third parties, making it easier to implement tools such as magnifiers and screen readers. It proves very useful also for testing utilities. Microsoft has implemented the accessibility interfaces for the standard Windows controls.

AccExplorer (download) shows you the test application structure:

You see nice hierarchical window structure. Every object has several properties:

Name - e.g. caption of button
Value - e.g. value of list box
Role Text - type of the component
Location - position on the screen
State - e.g. disabled, normal, etc.
Def Action - default action for the component

The properties provides more information than Win32 API. But when you look closer, you see it is not enough:

We still cannot distinguish the similar controls. Both buttons have role push buttons and can be distinguished only by displayed name. Which is problematic when names change or you need to test localized applications.
Some components do not have name at all. In our example it is the text box - its name in AccExplorer is NAMELESS.
The third party components usually lack support for the accessibility in the same quality as Microsoft. For example, DevExpress grid only tells you "I am a grid". It does not tell you how many rows it contains, what cells are there, etc...

The good news is developers can change this behavior. They can define AccessibleName property for a component so we can later easily find exactly what we need. If I have set AccessibleName for the text box to myTextBox, we would have seen myTextBox instead of NAMELESS in AccExplorer now. For grid, they can define the whole structure of accessible objects to represent the grid (see Exposing Data Tables through Microsoft Active Accessibility). Unfortunately, when your application does not have sufficient support for accessibility, it is quite lot of work...

Microsoft tries to address testing issues with his new framework in .NET 3.5: Microsoft UI Automation. I have not tried it as our applications do not run on .NET 3.5.

Also DevExpress promised to enhance their components with better support for UI testing tools - see the 2008 roadmap.

But we don't want to wait, right? We want to test our .NET application right now! I will show how in the next article.

Exploring test application: Win32 API

2008-06-04T00:30:00.005+02:00

Let's look on what we can discover about our simple test application when it is running. Before IronPython, we had two options:

Win32 API
Accessibility

Win32 API provides several functions that return information about an application. First, we have to find the appliction handle. We utilize functions EnumWindows and GetWindowText from Python for Windows extensions project:

def enum(hwnd, extra):
   global app_handle
   if winxpgui.GetWindowText(hwnd).find('GUIAT - Proof') >= 0:
       app_handle = hwnd

app_handle = None
winxpgui.EnumWindows(enum, '')
print 'Test application handle:', app_handle

When we know the application handle, we can enumerate its children:

def enum_child(hwnd, extra):
   print '%s %s:    %s' % (hwnd, winxpgui.GetClassName(hwnd),
           winxpgui.GetWindowText(hwnd))

winxpgui.EnumChildWindows(app_handle, enum_child, '')

When you run the whole script (source), you get:

Test application handle: 2949744
2621886 WindowsForms10.BUTTON.app.0.378734a:    Add Item
7668314 WindowsForms10.STATIC.app.0.378734a:    New listbox item
4194952 WindowsForms10.EDIT.app.0.378734a:
2753142 WindowsForms10.LISTBOX.app.0.378734a:
3342924 WindowsForms10.BUTTON.app.0.378734a:    Quit

Here is the catch. How shall we identify Add Item button from Quit button? Both have the same class name WindowsForms10.BUTTON.app.0.378734a. Sure, the text differs, but this isn't always true. Imagine two text boxes - both having the same class name WindowsForms10.EDIT.app.0.378734a. What then? Of course, you can check positions. But this is leads you back to record/play tools and that is exactly what I want to avoid.

So this is the terminus for Win32 API. Next time - Accessibility.

GUI Application to Test

2008-05-28T20:40:00.012+02:00

Let's start with something easy. We have a Windows GUI application that looks like this:

The application contains a text box, two buttons, and a list box. It simply adds a text from text box as the last item to the list box (exe, source).

The testing steps might be as follows:

Run the application.
Check the 'New listbox item' fields is empty.
Check the list box contains three rows with texts: 'This is', 'GUIAT', 'demo.'.
Enter a text (e.g. 'new line') into text box, press 'Add Item' button. Verify your text ('new line') appears as the fourth line/item in the list box.
Press 'Quit' button. Verify the application terminates.

Any record/play testing tool can do the test up to point 4. There it cannot verify whether the text was added to the correct place in the list box. These tools also cannot handle moving 'Add Item' button closer to the text box. They would then click to empty place. Sure there are more sophisticated tools that can handle the above problems. But I do not know about any for free.

Next time we try some dead ends from my beginnings :-)

The beginning

2008-05-22T17:33:00.008+02:00

Testing GUI application can be tedious work. Usually, you have to manually click through the interfaces. The first round is fun, the second is OK, and from the third round on it is boring.

When I joined Radiant, I started to think about automation. I searched on Internet but I did not find anything satisfying. All tools were basically record/play applications. That is not sufficient for testing. There are many concerns, for example:

How do you verify the test result?
How easy can you change the script (add testing of a new field, new form, etc.)
Scalability - how easy can you join basic scripts and create bigger (regression) script?
How the test application works with your amended components?
etc.

I know the testing tool cannot do everything. So I set up several goals I'd like to achieve:

Allow to control GUI application.
That means to start it, navigates through it, close it. To know its status.
Allow to read values from the screen.
You have to know what is on the screen to be able to test it.
Allow to set values.
Also, you have to be able to set/write values into the application to be able to test it.
Easy to create.
Testers are not experienced programmers. The tool must be easy to use. Anybody, who knows what a program is, should be able to write a test script.
Easy to maintain.
When the tested application changes, amending a test script should not be necessary or be a piece of cake.
Scalability.
Joining test scripts together, creating regression scripts.

In next few weeks, you'll find out on this blog how I succeed in this task.