igorbrejc.net

A few days ago I wrote about my first experiences in using White. I mentioned I wanted to create a facade around the White API in order to avoid constantly retyping the same code for common use cases. Since fluent interfaces are in fashion now, I decided to create a fluent facade. Just joking, of course.

I’ll present the facade through a few tests of a Kosmos GUI, which is currently under construction. Kosmos GUI is a MDI application for displaying maps from OpenStreetMap geo data. You have to load a Kosmos project, which contains information about where to find the data and how to render it. So after starting the application, the first user action would typically be to open the project:

After clicking the File|Open Project menu item, a dialog for selecting the Kosmos project file appears:

One you have selected the project file, a progress box is shown with an option to cancel the operation:

If you let it finish, a map appears and some additional menu items are now available:

Test Code

Here’s a sample test case which goes through the above steps:

After loading the project the test case executes some of the zoom functions available in the menu. And here’s a test case which cancels the project loading (and then checks that the View|Zoom In menu item is still not enabled):

Hopefully the code is self-explanatory. The basic idea is for the facade to remember the current window or other UI element to perform actions on. You can change the active window at any moment. The facade is also supplied with some basic assertion methods useful in the test code (they throw InvalidOperationExceptions, so you can use them with any unit test framework).

Oh I almost forgot. This is how you instantiate the facade:

And if the facade does not offer enough for you, you can always access the underlying White’s Application object through facade.Application property.

Download

You can download the latest version of the WhiteFacade class from here. I have to warn you though: the class is in its infancy and will evolve through my effort on testing Kosmos GUI. It provides only for some basic use cases, but I think those common cases represent the majority of the GUI test code. I just wanted to give you an idea on how to make writing GUI test code as painless as possible.

After a few weeks of work on my new framework for multidocument interfaces called BrekiViews (yes, I know I promised to write a little about it, but I just didn’t have enough time and concentration to put the brainstorms in my head into some coherent words) and refactoring Kosmos code to use it, I’m finally able to show some basic stuff in the new Kosmos GUI application. It’s all pretty simple at the moment, I got just one menu item working: File | Open Project. But I wanted to use this opportunity and start using White from ThoughtWorks to write automated GUI tests, since I was looking forward to trying the White out.

Documentation (Or The Lack Of It)

Unfortunately, the first impressions aren’t that good. The worst problem is lack of documentation. There are some pages written on the project’s CodePlex page and I also stumbled on a few posts which have some more examples on how to use it, but in general the API is undocumented. NDoc documentation that comes in the latest release just contains the API reference, without any human-generated documentation. It even states that it’s based on .NET Framework 1.1, which was obviously autogenerated and is probably wrong, since the API includes generics. I haven’t checked the source code directly though, maybe there is something there.

Yes I know, it’s an open source project and I shouldn’t expect too much, but I still think that such a project for which the whole purpose is to be used through an API should contain at least some documentation. Otherwise you spend a lot of time experimenting with the API to achieve the results.

Keyboard Problems

Like most other UI testing frameworks, White too suffers from quirks. I wanted to start the “Open Project” menu action using the keyboard shortcut, so I tried with:

Which ended up forcing me to restart the computer, since the OS started acting very funny, as if the Ctrl key was still being pressed. I guess I should have added

to unpress the Ctrl key, but I’m not sure, since I couldn’t find any documentation on using the keyboard in White. Anyway, a helper method that would accept a shortcut as a string (something like KeyboardInput.Press (”Ctrl+O”) would be very helpful).

Clicking The Menus

After abandoning the keyboard approach, I tried to start “Open Project” by clicking on the menu item. I did some experimenting and finally managed to write a basic test, here’s the whole test fixture:

White Facade

From my experience with other UI testing frameworks, if you intend to do more than a few simple UI tests it is a good idea to create some sort of a facade around the testing API. This way you simplify the interface to common use cases you typically use and eliminate any nasty quirks (like memory or resource leaks). Bil Simser has done something to that affect for White, although I don’t support his views on (not) using Setup and Teardown methods in unit tests.

Even better: why not implement a fluent inteface facade? Something like

or

would be much nicer than the above code, don’t you think? Okey, I’m oversimplifying, I know :), but I will try to do something in the direction of a fluent interface facade, since I don’t intend to abandon the White just yet.

.NET Development

• informIT: Allocating Small Data Structures - discusses differences in memory allocation of millions of classes vs. structs
• The empty try block mystery
• How to Expose Your Collections Safely - using ReadOnlyCollections
• Simpler Code Add-In for Visual Studio 2008
• The cost of abstraction - Part 2 - Part 3
• Emacs is better than Visual Studio as a C# Development Tool?!!

Development In General

• stackoverflow.com - Joel Spolsky and Jeff Atwood come together
• 4 places for developers to make money
• Do you Really Want to Be a Development Team Leader?

Mapping

• KML is now an international standard

Misc

• Mike Swanson - Over One Million Wallpaper Visitors
• Silence Your Hard Drive with Elastic Suspenders
• The Economist: Power plays and Energy Monitor Comparison Chart

.NET Development

• CodePlex: NetFXHarmonics DevServer - a web server hosting environment built on WPF and WCF technologies that allows multiple instances of Cassini-like web servers to run in parallel
• Gallio Archimedes
• CodePlex: SlickCodeSearch - A WPF based application that lets you index and search through your source files (C#)
• Choosing a UI Pattern (MVC, MVP, and ASP.Net MVC)

Mapping & GPS

• Google on OSM Maps - compare Google Maps and OpenStreetMaps of Google HQ
• CodeProject: Writing Your Own GPS Applications: Part I
• Down to earth: Geotagging photos - instructions on geotagging your photos and also a link to geotag, a free geotagging software

Misc

• Look out VirtualPC and VMWare… VirtualBox is in the house
• Time.com’s Top 25 Blogs — the one-page-version
• Microsoft Surface videos

I keep finding new ways to loose half a day in debugging and troubleshooting when working with timezones and UTC time in .NET Framework.

A little background into my problem: we’re trying to use UTC exclusively in our application. So, for example, whenever we ask for current time, we use DateTime.UtcNow property instead of DateTime.Now. And also we are strict on a policy of naming all variables that hold UTC time with an Utc suffix, example: currentTimeUtc. This is just in case nobody gets confused of the timezone used in a variable. This is especially useful when our application communicates with the world, since some external services work with local time only, so there needs to be a conversion. And I recommend using this policy on database columns too, for the same reason.

The latest hassle has to do with converting UTC time to and from a string. As we discovered, we naively belived that all that was necessary was to use DateTime.ToString ("u", CultureInfo.InvariantCulture) to convert the UTC timestamp into the string. Later if we wanted to convert it back into an UTC time, we simply called DateTime.Parse (timeString, CultureInfo.InvariantCulture) to get the DateTime value back.

Off course this doesn’t work. The ToString() method converts the time into "2002-12-10 22:13:50Z" format. But the Parse() method (well actually the override we used) first parses it into UTC time and then automatically converts it into the local time. So we end up with a variable marked as UTC but actually holding the local time, which is no good.

The solution (or what I hope to be the solution) is to use
DateTime.Parse (timeString, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal) override. Let me quote the MSDN documentation on the AdjustToUniversal enumeration value:

Indicates that the date and time will be returned as a Coordinated Universal Time (UTC). If the input string denoted a Local time (through a time zone specifier or AssumeLocal) then the date and time is converted from the local time zone to UTC. If the input string denoted a UTC time (through a time zone specifier or AssumeUniversal) then no conversion occurs. If the input string did not denote a Local or UTC time (no time zone specifier, and neither AssumeLocal nor AssumeUniversal was included), then no conversion occurs and the Kind of the resulting DateTime is Unspecified. Cannot be used with RoundTripKind. 

Just another reminder that if you want to use UTC times in your applications, you shouldn’t assume anything. At least when the .NET Framework is concerned

.NET Development

• FormatWith 2.0 - String formatting with named variables

Development In General

• Coding Horror - UI-First Software Development
• Mono 1.9 Released

GPS

• Garmin loses its way
• Navteq’s sale faces a detour
• MyTourbook - free software to visualize and analyze tours which are recorded by a GPS device, ergometer, bike- or exercise computer
• The state of Terminal 5
• Dash Express Hands-On Preview

Miscellaneous

• IconFX - a complete all-in-one solution for icon creation, extraction and editing (part of the Portable Freeware collection)
• Google Earth Can Make You Famous

I finally got around to try out Osmxapi and I developed a simple client to download the latest data for Slovenia. I played around with some simple batch files to download the data, convert it to the Garmin’s img format (using Mkgmap), zip it and upload it to an FTP server. So the updates of Slovenia map should now be more frequent.

Good news for hikers (and cyclists) is that I created a separate version of Slovenia map which has more visible hiking related features. The problem with standard Garmin features is that they show footways as thin dashed lines which are very hard to see when you’re outdoor in the sun. Also, the tracks (unpaved roads) are shown in practically the same way as minor forest footways.

The hiking map I prepared shows footways clearly (as thicker red solid lines). Tracks are shown as thick gray lines (I borrowed the “border” feature for this). All other roads are shown using a same feature, so there’s no distinction between minor roads and motorways, but I think this is not really important for hiking. Anyway, if you have enough free memory on your unit, you can upload both maps and switch between them when needed.

You can find the maps on the Garmin Stuff page.