Here’s what it looks like:

The spiral is composed of segments that progress outward radially from the origin. Each successive endpoint is computed as a polar coordinate (Degrees, Distance), then converted to a cartesian (X,Y) coordinate relative to the origin.

This also shows the basics of using LFOs (low frequency oscillators) to automate parameters that change over time: a Sawtooth LFO is used to rotate the spiral, and a Sine LFO is used to grow and shrink it.

You can download the source file here:

SpiralExample.qtz

Coming to QC from other languages (in my case C#, Ruby and JavaScript for the most part), there are a few gotchas… or perhaps my brain is slow to adapt. Anyway, one of these has to do with the Iterator and Iterator Variables patches.

So, the way this works, is you create an Iterator patch (think “for loop” if you are familiar with C-style languages). The Iterator patch is a “macro patch”, which means that it contains other patches. Within the Iterator patch (right-click and select “Edit Macro Patch…”) you create an Iterator Variables patch, which provides your current index, the number of iterations, and a “Position” output that doesn;t quite do what I thought it might:

So you can think of this as:

I’ve attached a Quartz Composer patch that demonstrates the behavior visually, and shows how to use the iterator and iterator variables patches to draw a set of spheres arranged in a circle about the origin:

IteratorExample.qtz

You can get it from the github download page.

Changes since my last in-depth post about StorEvil:

- Added HTML reporting of spec results using the Spark View Engine.
- New command “storevil init” which creates a config file & spark template in the current directory as well as some examples.
- Ability to bind tables to arrays of parameters that are custom types. (more info on the github wiki).
- Added an example that implements Conway’s Game Of Life using the Cucumber features created by Corey Haines.
- Hacked out a very early semi-functional ReSharper runner (not included in the binaries yet… only supports ReSharper 5 Beta). I’ll work on this more once ReSharper 5.0 is released.
- Support for dependent contexts: StorEvil will inject any constructor parameters into your context classes, and reuse the same contexts throughout the execution of a scenario (so you can break up your contexts into classes irrespective of their shared context). (more info on the github wiki)
- Cleaned up some namespace inconsistencies
- Reworked and simplified a bunch of complex code (Thank you Reflector & the CodeMetrics plugin)
- fixed a bunch of bugs (of course)

If you take a look at it let me know what you think.

It’s sort of a pun… first off, obviously, in agile development, a unit of work to-be-done is often referred to as “story”. In StorEvil, “Story” refers to a set of scenarios (basically a single natural language specification file).

Also, many years ago, when I was young and just getting into jazz, I listened to a certain live Charlie Parker album quite a bit.

Also, I’ve always had the suspicion that the whole idea of natural language specs might be slightly Evil.

So, being an old DOS/Windows guy, I just took “Storyville” and twisted it into an 8-character name that almost makes sense.

So there you have it, the triple-entendre behind the StorEvil name.

This is the first in a series of posts about a tool I wrote a while back, and have recently picked up again, called StorEvil.

You can check out StorEvil on GitHub

After I wrote it I sort of lost interest in this whole approach, although I paid some attention to Cucumber as it gained popularity.
Recently, at an Alt.NET Seattle meeting, I saw a demo of SpecFlow, which is a similar tool for .NET.

SpecFlow is a nice tool insofar as it is basically a reimplementation of Cucumber in .NET.
However, I think that some of the nice metadata tools (Reflection) that we have in .NET can provide for a much richer experience.
This is not to imply that I think .NET is better than Ruby for this type of thing, by any means. In fact, quite the opposite.

But, if you are going to take on the pain of static-typing, I think you should partake of the joy of System.Reflection to provide a tool that does things that are simply not possible or very difficult in Ruby.
Otherwise, you might as well just use Cucumber and IronRuby… Or eschew .NET altogether if possible.

Now, big disclaimer: StorEvil is not very polished. It may not work on your machine. It may not work as expected.
I’m pretty sure that it won’t reformat your hard disk, but beyond that I make no claims.

What is StorEvil?

Well, if you know what Cucumber is, you can basically think of it as a Cucumber-ish tool for .NET that allows you to easily write .NET code to interpret natural language specifications.
If you don’t know what Cucumber is, I would advise you to read about it.

StorEvil is a tool that you can use to write specifications in English, and then execute those specifications.
It supports a set of natural language that is a subset of the Gherkin language used by Cucumber.

It supports .NET languages such as C#.
It has only been tested on Windows (so far).
It only supports English (so far).

Why StorEvil?

Reflection-based language matching

Other similar tools use regular expressions, which makes sense for Ruby.

In .NET, there is a rich Reflection model which gives access to the method names, parameter names and type info,
which can help to reduce noise and code-duplication.

In StorEvil, although Regular-Expression matching is supported, matching based on the names of functions is the preferred method:

For example, in order to match the following:

In SpecFlow, and similarly in Cucumber (ignoring the language differences between C# & Ruby), you would write something like this:

In StorEvil, you could use similar syntax to the above, OR, you can write it in as follows:

StorEvil splits the method name into its constituent words and matches the values to the parameters based on the names of the parameters (accountType and amount).

Context Chaining

In StorEvil, your Context class methods (like Steps in Cucumber) can return any object, which can then be used to fulfill the remaining grammar on a line.

For example, in the specification alluded to in the above example, you may end up with the following similar steps:

In StorEvil, rather than creating a separate step for each one of these, you could do the following:

StorEvil will first invoke AccountTestContext.GivenIHaveAaccountType_Account(), passing in the account type.
It will then take the returned AccountOptions object and invoke the appropriate method to complete the rest of the step.

You could also declare a method to return object or any other type, and return different types of objects from the function depending on the parameters.

This can be chained to as deep a level as desired.

On successive steps during a scenario, StorEvil will preserve the same context objects…
meaning that you can use private variables in the context objects to maintain state between steps.

Extension Method Support

StorEvil can invoke extension methods. For example, to interpret the following:

You could write something like this:

StorEvil will invoke the .ShouldEqual() extension method on the number returned by AccountTestContext.MyTotalBalance property, passing in “$42”;

Executes in the console

StorEvil is executed via a simple command-line interface. This is my personal preference. It might not be for you if you are not comfortable on the command-line. Integration with ReSharper is something I’ve looked into but frankly, it’s kind of a bear and not high on the priority list right now.

It was originally written to generate NUnit fixtures (and still supports this), although there are some limitations to the NUnit fixture generation.

Why not StorEvil?

Less polished than other options

StorEvil does not have VisualStudio integration.

StorEvil does not have NAnt or MSBuild tasks. (yet)

It does not have TDD.NET or Resharper integration.
(Unless you use it in NUnit generation mode)

Update: StorEvil now has a ReSharper runner

Overall, it just a less-used tool than the other options.

Is natural language testing appropriate?

There is definitely an extra cost to writing natural language specs as well as context classes.
Sometimes it can even feels like “writing the tests twice”.

Another option is to use a tool whose output is close to the natural language specification.
For .NET development, Machine.Specifications (MSpec) is a good choice.

Other similar tools

Cucumber

Cucumber is by far the most established BDD tool, and if you use Ruby you have probably heard of it.
It is in use by a large number of people, supports many languages, and is under very active development.

SpecFlow

SpecFlow is another .NET tool that is similar to Cucumber. It also has a fairly active community.

Here’s a run through  Roy Osherove’s Calculator Kata, in JavaScript, using Screw.Unit.

It was quite educational to do this kata and watch it back on video. The main things I learned were:

I am a horrible typist.

Writing code takes a lot longer than I think it does.

I expected to be able to do the beginner steps in about 10 minutes, but it actually took more than twice that long. Some of this is down to unfamiliarity with the editor (RubyMine), and some of it is standard programmer optimism.

It is embarrassing to watch yourself code….

I did this kata three times so I’ve watched myself code more than is healthy.

… but it is a great learning experience as well.

I see a lot of areas I can improve on, coding-wise, and there are some things I do a lot that I’ve never noticed before.

Without further ado…

Here it is. The first 21 minutes are the “beginner” steps, the following steps are about 15 minutes, and the remaining few minutes are code tidying. There is sporadic commentary for the bits that I feel are noteworthy.

[vimeo 8708519]

I’d call it a match made in heaven, if there was a heaven.

- Larry Bird, on Michael Jordan

1. Install IIS6 compatibility, Metabase, and Application Development Features from Control Panel\Programs and Features\Turn Windows Features On and Off.

2. Follow the instructions here: How to map .rails to the asp.net runtime on IIS7.

3. If you are using <httpModules> in web.config, change the application pool to the Classic Application Pool (in IISManagementConsole, click the Advanced Settings… link on the right side). Alternatively, follow the instructions to migrate to the integrated pipeline mode (I couldn’t for this project).