I was really impressed by the amount and quality of the new features. Some of the most noteworthy ones in my opinion are the AssertEx.That syntax, the Gallio.Ambience object store, and the highlighting of differences in assertions.

I’ve been away from Gallio and MbUnit the last couple of months for a number of personal reasons, but I’m quite glad to see that we’ve got new people contributing with their time and skills, and once more I’m amazed by Jeff’s energy to keep working so hard on all this stuff.

Oh, and before I forget it, the Gallio Book is now online. I wrote the getting started chapter (right now the code listings don’t look good, but I hope we can fix that soon) and helped a little more, but it was Jeff who got the publishing done at the end. There’s not too much content so far, so people are really welcome to contribute.

Download Gallio/MbUnit 3.04!

During the week I’ll try to update a little application (a log viewer) I wrote with the beta 2 and see how it works. I’m particularly interested in seeing the new controls and the improvements on the old ones. But anyway, I have to get back to work now!

I wrote a “Why This Book?” section, and to my surprise it was a lot harder than the technical content. I’m still not glad with it, but for now I’ll focus on the things that people really read and care about :)

I hope to put it on the web site during this week and to start working on other kind of output formats too. It’s quite satisfying to see this project becoming a reality :)

In my previous post I said I was going to transform the source XML files using .NET, but it was getting too time consuming, so at the end I used the Java flavor of the Saxon XSLT processor. As usual, it was harder than I thought at first because of all the little details that must be taken care of, so I will blog about the process soon.

This week I started to research how to convert what we have so far to HTML, so we can upload it to the web site. Since DocBook is XML-based it’s not surprising that the simplest way to do it is by using XSL stylesheets. A free set of them is available at the project’s web site and there is even a full book devoted to them.

To make things as smooth as possible I decided I’d do the processing in .NET, but it was not as easy as I was thought it would be, so I decided to blog about it in case anyone else needs a quick start.

Let me start by showing you the sample book we’ll be transforming:

It’s pretty basic, we only have a title and two chapters. Notice that I’m using XInclude instead of entities to include the chapters. In case you are interested, the book “DocBook: The Definitive Guide” includes a list of the tradeoffs involved in choosing either approach. To be honest I don’t find any compelling reason to prefer XInclude (it was Jeff who persuaded me!), but I’ll leave that discussion for another post. Here’s the XML markup for Chapter 1:

Chapter 2 is the same thing. In the real Gallio book we also have things like code listings and images. I still don’t know how to format the code listings (that will be the subject of a future post), but images just work without doing anything special.

Before I show any code you’ll want to download the DocBook XSL stylesheets from the SourceForge project. Make sure you pick the DocBook XSL-NS stylesheets (the docbook-xsl-ns-xxx package) or you’ll get a warning when using them (”WARNING: cannot add @xml:base to node set root element. Relative paths may not work”). They are the recommended DocBook V.50 stylesheets anyway. When you decompress the package you’ll see a bunch of folders and files - don’t panic, we only need to mess with one of them.

Now we are ready to start. We’ll use the XslCompiledTransform class (which is .NET’s XSLT processor) to load and transform our DocBook file. There are two steps involved: loading the stylesheet and applying it to the XML file.

1. Loading the Style Sheet

We want the book in HTML format, so we have to use the ‘docbook.xsl’ stylesheet (located in the html folder), which generates a single HTML output file. There’s also another potentially useful one called ‘chunk.xsl’ that generates multiple linked files, which is best suited for a book, but when I tried it I got an error that seemed to be the stylesheet’s fault (something like “an ‘xsl:apply-imports’ element can only appear within a ‘xsl:template’ element”), so we’ll stick to the single output file for now :)

This is the code to load the stylesheet:

We are basically creating a XmlReader object pointed to the stylesheet we want to use and passing it to the Load method of a XslCompiledTransform instance. This is pretty straightforward, but we need to set a couple of options to make it work:

• By default DTD processing is prohibited, so we’ll get an XmlException when loading the stylesheet. To fix this we set the ProhibitDtd property to false in line 4.
• The document() function is disabled by default. This is used by the stylesheets, so we need to enable it or we’ll get yet another exception. This is done in lines 9-10 where we create a new XsltSettings object and set its EnableDocumentFunction property to true.

2. Applying the Transform

This is the code required to apply the stylesheet:

Again, a couple of points to notice:

• In line 4 we set the conformance level to ConformanceLevel.Auto through a XmlWriterSettings instance. For some reason if you don’t do this an InvalidOperationException is thrown complaining about the validity of the output file, even though the HTML file looks fine.
• We can give parameters to the stylesheet. In this case, in line 9 I’m defining the name of the CSS stylesheet to use (this will generate a link tag in the output file).

In case you are wondering, the CreateReader method looks like this:

We are just creating a XmlReader pointed to the book file and with the ProhibitDtd set to false as we did for the stylesheet.

We run the code and see the following output (after manually opening the resulting file of course):

As you see the title is OK, but the chapters are not included. The following warning give us a clue:

Element include in namespace ‘http://www.w3.org/2001/XInclude’ encountered in book, but no template matches.

It turns out XslCompiledTransform doesn’t support XInclude. Luckily there’s a project called Mvp.Xml that provides this functionality through a class called XIncludingReader. If you read the documentation in their wiki it looks as it’s only a matter of returning a XIncludingReader instance from the CreateReader method to make everything work, but it’s not. For some reason, a XmlException is thrown complaining about the DTD processing prohibition again (don’t you start to hate that little feature?). The solution is to subclass XIncludingReader and override its Settings property, making sure the returned object has the ProhibitDtd property set to false. None of the constructors in the XIncludingReader class accepts a XmlReaderSettings object, so it’s the only way.

This is the new class:

With the new code everything works as expected:

It took me a while to figure the subclassing thing out, because internally the XIncludingReader class uses a normal XmlReader where the DTD prohibition is disabled. I don’t know how the XslCompiledTransform class interacts with the reader it receives, but it (or some other class) must be looking at this property at some point because otherwise the exception wouldn’t be thrown. I was about to start debugging into the Framework’s source to see what was going on when I thought of subclassing. The clue was discovering that XIncludingReader.Settings was always null. Seeing now all the effort it took, I wish I’d used entities from the beginning, but anyway.

So, that’s all. I’ve uploaded a zip file with the sample code. Please make sure you fix the path in line 48 of Program.cs before running it.

Hope it helps :)

One of the cool things about Gallio is that it opens the door for creating some powerful tools on top of it (hint: even commercial tools ;)). A few weeks ago Jeff blogged about one of such potential tools, an integration test management platform called “Archimedes” and composed in principle by the following components:

• A distributed test runner.
• A web-based management console.
• A repository for historical test data.
• A deployment engine.
• A scheduler.
• A notification service.
• A reporting, trending and statistics module.
• A data feed and web service for mash ups.
• Documentation.

Since Jeff is pretty busy right now he asked me to start and lead the project, and I accepted immediately (although I must admit I was a little afraid to). I think this is an exciting opportunity, but also a big responsibility. In my opinion, one of the biggest challenges in software development today is to make testing easy and cheap, there’s lot of room for improvement and we are not near to have a tools ecosystem as rich as we have for coding for example. I think the reason is that testing is a hard problem.

You can see in the component list that this is not going to be a trivial effort, but fortunately so far it looks I will get help from some smart people. My intention is to divide the project in small achievable milestones - better to have a few completed features than a lot of unfinished ones. We will see how it goes.

If this sounds interesting I invite you to come and join. For now the best place to show up is the Gallio dev list, but we will probably have a dedicated list soon.

Happy testing!

• The Gallio Project
• The Gallio dev list
• Jeff Brown’s blog (recommended reading!)
• Jeff Brown’s post about Archimedes

I used to have a tech blog at http://www.hpoffice.cl/julian/, but unfortunately the server died and I could not recover the backup. It’s a pity because I had a bunch of posts already, but anyway, I guess I have to think of this as an opportunity for doing things better. I don’t like to do things twice, so it took me a while deciding to start blogging again.

In case you are interested, my name is Julián Hidalgo and I’m from Chile, South America (that’s why my English is so bad). I’m a .NET developer and I’m part of the MbUnit and Gallio projects, so I’ll be blogging mostly about .NET, general software development and those projects.

I’m planning to be posting new content at least every two weeks, so stay tuned.

I guess that is. Thanks for reading and see you soon!