On Friday, February 24, 2012 03:12:08 Chris Pons wrote:
> Ok, thanks.
>
> I haven't run into version(...) yet. Would I be correct if I
> assumed that this version of void main: void main() {} would only
> run if -unittest was in the command line?
Yes.
version(symbol)
means that anything within that block is compiled in if the version symbol has
been defined (either in code or via the command-line). For instance,
version(Posix) {}
else version(Windows) {}
else static assert("Unsupported OS");
would give you three different versions of the code. The Posix one gets
compiled in on Posix systems. The Windows one gets compiled in on Windows
systems, and the third block gets compiled in on everything else (in this
case, with a static assertion so that you get an error when you try and
compile with an unsupported OS). The version unittest is enabled when you
compile with -unittest, so anything in version(unittest) gets compiled in.
> Also, what should be in a unit test? Test cases to make sure
> certain functions/classes are working as you intend them to?
Yes. Typically, after every function you put a unittest block with assertions
that verify that that function is working correctly. And unit tests which
tests combinations of functions can be useful as well. But regardless, the
idea is to use unit tests to verify that your code works how it's supposed to
and fails how it's supposed to (e.g. when certain input should result in an
exception being thrown) so that you know not only that your code works
currently but that your code continues to work when you make changes to it in
the future. It makes for much more robust code and often actually increases
the speed of development, because you end up with fewer bugs (since you catch
them when you write the tests, which you typically do when you write the
code).
- Jonathan M Davis
