Agile software development techniques have long been utopia for low level system developers. The C programming language has been the most reasonable choice for implementing hardware near applications and drivers; But C was not designed with agility in mind. Hence methods like test driven development has been a pain to implement using C.
Now an alternative exists: The D Programming Language is designed to combine the low level programming abilities and performance of languages like C and C++, with the productivity features of modern languages.
You could describe D as C with features like object oriented programming, exception handling, garbage collection and design by contract. Cool agile features indeed, but D has another one that I instantly fell in love with: built in support for unit testing.
In D you can declare unittest blocks.
unittest {
assert(sometest, "sometest failed");
}
The unittest construct makes it very easy to practice test-driven development. For instance, lets say we want to create a new type for three dimensional vectors. In order to be test-driven we need to start with the test:
unittest {
Vector3 v;
}
We compile the program using the -unittest switch.
dmd -unittest test.d
Of course we get a compiler error, Vector3 is still undefined. Lets define it.
struct Vector3 {
}
This time the program compiles. Back to the unittest. Now let’s try a simple assignment.
unittest {
Vector3 v = Vector3(1.0, 2.0, 3.0);
}
This, again, produces a compile time error. Vector3 doesn’t have the x, y and z fields, so we implement them.
struct Vector3 {
real x, y, z;
}
The code passes compilation. Next step: implement vector addition. We start with the test.
unittest {
Vector3 v1 = Vector3(1, 2, 3);
Vector3 v2 = Vector3(3, 2, 1);
Vector3 vr = v1 + v2;
}
As we expect, the code doesn’t compile. We need to overload the + operator.
struct Vector3 {
real x, y, z;
// Overload + operator
Vector3 opAdd(Vector3 a)
{
return Vector3(0, 0, 0);
}
}
Now the program compiles, but we don’t know if the add operator produces the right result (which it doesn’t with the current code). To check the result we can use assert.
unittest {
Vector3 v1 = Vector3(1, 2, 3);
Vector3 v2 = Vector3(3, 2, 1);
Vector3 vr = v1 + v2;
assert(vr.x == 4);
assert(vr.y == 4);
assert(vr.z == 4);
}
We compile, and it compiles without error. To run the unittest code we simply run the program. Unittest code is executed after program initialization, but before the main function. If a unittest fails the program terminates prematurely. Our program terminates (as expected) with an AssertError. Lets correct the add operator.
struct Vector3 {
real x, y, z;
Vector3 opAdd(Vector3 a)
{
return Vector3(x + a.x, y + a.y, z + a.z);
}
}
It compiles and runs without errors. Great!
As you can see, test-driven development is a very smooth and simple process in D. There is no need for a separate framework, just compile and run your application. Also, the test code dwells close to the production code, which makes it easier to maintain and keep up-to-date. In fact, you can put unittest blocks anywhere in your code, even within the piece of code you are testing.
struct Vector3 {
real x, y, z;
// unittest blocks are allowed
// within structs.
unittest { ... }
}
Any type of code is allowed within a unittest block. This means that you can declare functions to do repetitive tasks.
unittest {
function assertEqual(Vector3 a, Vector3 b)
{
assert(a.x == b.x);
assert(a.y == b.y);
assert(a.z == b.z);
}
Vector3 v1 = Vector3(1, 2, 3);
Vector3 v2 = Vector3(3, 2, 1);
assertEqual(v1 + v2, Vector3(4, 4, 4));
assertEqual(v1 - v2, Vector3(2, 0, -2));
}
The test code is only included in the executable if it is compiled with the unittest flag, so there’s no need for a separate test project or conditional compilation. This is a very clean solution, highly suitable for a traditional language that compiles directly to machine code. Although I’m a big fan of testing framworks such as JUnit, I find it much easier to work with the built in unit testing features of D. Of course you don’t have advanced features like mock object support, but I guess that will be offered soon with some kind of unittest-based framework add-on.
If you have doubts about the foundation of the D Programming Language, you should be relieved to hear that it’s been designed by Walter Bright, who have spent almost a lifetime constructing C and C++ compilers.
You’ll find the complete code within my code sample pages.