anchor.diff:  
   What is the funny looking `mock()` function?
   
  -A mock is basically a programmable object. In C objects are limited to
  -functions, so this is a mock function. The macro `mock()` compares the
  -incoming parameters with any expected values and dispatches messages
  -to the test suite if there is a mismatch. It also returns any values
  -that have been preprogrammed in the test.
  +A mock is basically a programmable object. In C objects are limited 
  +to functions, so this is a mock function. The macro `mock()` compares
  +the incoming parameters with any expected values and dispatches 
  +messages to the test suite if there is a mismatch. It also returns 
  +any values that have been preprogrammed in the test.
    
   The test is `invokes_callback_once_for_single_word_sentence()`. It
   programs the mock function using the `expect()` macro. It expects a
  -single call, and that single call should use the parameters `"Word"` and
  -`NULL`. If they don't match, we will get a test failure.
  +single call, and that single call should use the parameters `"Word"` 
  +and `NULL`. If they don't match, we will get a test failure.
   
   So when the code under test (our `words()` function) calls the
   injected `mocked_callback()` it in turn will call `mock()` with the
  
positive.code: assertions accept anything that can be cast to `intptr_t` and simply
  perform an `==` operation. The string comparisons are slightly
  different in that they use the `<string.h>` library function
  `strcmp()`.  If you use `is_equal_to()` with `char *` pointers then it is the value of the pointers themselves that has to be the same, i.e. the
  pointers have to point at the same string for the test to pass.
  
  A cautionary note about the constraints is that you cannot use C/C++
  string literal concatenation (like `"don't" "use" "string"
  "concatenation"`) in the parameters to the constraints. If you do, you
  will get weird error messages about missing arguments to the
  constraint macros. This is caused by the macros using argument strings
  to produce nice failure messages.
  
  
  === Asserting C++ Exceptions
  
negative.code: 
  More work than I like to admit as it took me three goes to get this
  right. I firstly forgot the `+ 1` added on to `strlen()`, then forgot
  to swap `sentence` for `word` in the `(*callback)()` call, and 
  finally third time lucky. Of course running the tests each time made 
  these mistakes very obvious. It's taken me far longer to write these
  paragraphs than it has to write the code.
  
  
  