When I was learning Rails I set up Autotest on Ubuntu with Growl notifications, which I thought was a pretty slick idea. On Ruby this whole technique is super easy and efficient because Ruby is an interpreted language; there's no compile time to slow you down, and no other files to pollute your directory tree. Compiled languages don't have that advantage, but I think we deserve some continuous feedback too. Here I'll describe how to configure Watchr, a generic Autotest utility, to run compiled tests whenever a source file in the path is updated. This tutorial will use a C# example, but it's trivial to have it trigger on different file types.
First, we'll need to install Ruby and Watchr. Because I'm using Windows I just downloaded RubyInstaller. Make sure you put the Ruby/bin directory in your PATH.
Next, download Watchr from Github, extract the archive and navigate to that directory. Or you can just download the gem directly, but some people might want to run the tests locally first. The following command will install the gem from the local directory:
C:\mynyml-watchr-17fa9bf\>gem install Watchr
Now that we have all the dependencies installed, we need to configure Watchr. This process is easiest if you already have a single point of entry for your continuous build process, but if you don't it's not that bad and you'll probably want one anyway. Now, at the same level as the directory(ies) containing your source code, create a text file. I usually call this autotest.watchr, but you could call it autotest.unit or autotest.integration if you're into that sort of thing. For now, just put in the following line in:
Yes, it's that easy. What this is doing is telling Watchr to monitor any files that match the regular expression (in this case a recursive directory search for .cs files) inside the watch() call, and then execute the command on the right. I also have it configured to return to the same directory when it's finished, but I don't know if that's actually necessary. The watch() pattern is what you would modify for different environments. For example, you could use
watch('./.*/(.*)\.[h|cpp|hpp|c]$')for a Mixed C/C++ system, or
watch('./.*/(.*)\.[cs|vb|cpp|h]$')for a .NET project with components built in different languages. An important thing to note is the $ at the end of the regex. Because it's likely that there will be a lot of intermediary files generated during the build process, we don't want a file which happens to match this pattern that's generated at build time to trigger an infinite loop of build & test (like happened to me). The heavy lifting is done here, but the stuff specific to your project happens in build/buildAndRunTests.bat. Let's take a look at that:
You'll obviously want to customize this to the specifics of your project, but right now it's hard-coded to call Visual Studio 2008's devenv.com (on a 64-bit OS) and build a project called Tests.Unit. For brevity it also assumes that nunit-console.exe is available on the PATH. Not terribly interesting, but that's the rest of the work.
Now to have all the magic happen. Run the following command in a new console window from your project directory:
That's it! Watchr is now monitoring for changes to files that match your pattern. Simply modify any file matching the pattern and watch the whole process set off. Once it finishes, you can hopefully see the results and it will wait for the next change.
Now there's one less thing you have to do during your heavy refactoring sessions, or just with day-to-day development.