New Mauve features

Lately I added two useful new features to Mauve:

  1. A facility for running JUnit tests inside the Mauve testsuite. (I already posted about this idea). This way we can include existing JUnit testsuites into our regression run, and it allows for new tests to be written in the JUnit style and run natively inside the Mauve harness.
  2. An API and harness extension for writing and running interactive tests. This is useful for testing complex issues that can’t otherwise be covered, like rendering issues in Swing, or complex interaction/integration issues. It also allows to easily convert testcases from the bug database to be integrated into Mauve as regression tests.

I hope that this will be useful and that it helps improving the overall quality of GNU Classpath.

Ubuntu Edgy

So I gave the latest Ubuntu beta a try. This is a very nice distro. All issues that I had with Dapper seems to be fixed, in particular, suspend-to-disk now works out of the box, 3D acceleration is supported for my graphics card by a free driver even and the DSDT issue is easily solved by putting the fixed DSDT into /etc/initramfs-tools (in contrast to recompiling the kernel on each and every update on the other distro I tried recently). This is the first distro (in almost 5 years) that my laptop likes 🙂
Besides that, everything else works very well too. I started out with a Dapper install and did an online upgrade, which goes without any problem at all, which is kinda impressive each time again, despite the fact that nowadays you can simply expect that from a Debian derived distros. (I sometimes wonder why other distros can’t accomplish that. It’s not that RPM in itself is worse than DEB. It seems more a matter of careful packaging and Q&A. Maybe it’s different priorities. But this is so enourmously useful, especially on server systems it seems unvaluable to perform seemless upgrades the Debian way.)

I’m looking forward to the final Edgy release, and I think this time I’ll order some free CD’s and hand it out to some friends.

I Had a Dream

Ok, actually I hadn’t. I woke up 3:00 AM with an idea in my mind, which kept me from sleeping the rest of the night. That’s why I’m so tired right now. But here comes the idea:

JUnit tests in Mauve

I imagine to implement the JUnit API in a way that makes all JUnit tests automagically a Mauve test. This seems quite easy, junit.framework.TestCase would implement the TestHarness interface and the test(TestHarness) method would call into the runTest() (or similar) method to actually run the JUnit tests. The JUnit assertions are then delegated to the Mauve TestHarness object. That should be fairly easy and enable the following:

  • Integration of existing JUnit tests (Harmony testsuite) by simply adding the JAR to the classpath and calling java Harness . The output would come in the Mauve style that you’re used to.
  • Implement new Mauve tests in the form of a JUnit test. This has a couple of advantages obviously, like having the setUp() and tearDown() methods called before/after each test, automatically test all test*() methods, setting the checkPoint for these test*() methods etc.

Mauve in JUnit

A similar concept could be implemented in the other direction. In order to have Mauve running a JUnit test runner, we would need a subclass of junit.framework.TestSuite, that loads and runs a set of Mauve tests, and generates a TestHarness for them, that calls into the JUnit assert*() methods. The set of Mauve tests to be run could be fetched from a system property or a configuration file, or maybe from the commandline like it’s done now in the Harness class. This would enable us to:

  • Run Mauve conveniently inside IDEs that support JUnit.
  • Generate test reports using tools written for JUnit.

I am hacking on the first idea right now and hope to show a working prototype soon.

The last round

So I’m starting my last semester these days. I still have to do my diploma thesis about performance optimization of a Java bytecode interpreter for embedded systems (JamaicaVM), and a seminar, in which I’m going to adapt FreeType‘s autohinting to GNU Classpath‘s TTF implementation. This is going to be an interesting semester (probably the most interesting of them all), and after that, in march 2007, I’m free, after almost 6 1/2 years of study :-D, yay!