anchor.diff:  
   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
  +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.
   
   
  
positive.code: sure it walks the sentence correctly, dispatching individual words as
  it goes. So what calls are made are very important. How to test this?
  
  Let's start with a one word sentence. In this case we would expect the
  callback to be invoked once with the only word, right? Here is the
  test for that...
  
  [source,c]
  ---------------------------------
  
negative.code: 
  The above example, as well as most of this guide, shows how to uses
  *CGreen* with C. You can also use *CGreen* with C++. This is actually
  quite simple. If you have installed the *Cgreen* library for C{pp} 
  all you have to do is
  
    * Use the `cgreen` name space by adding `using namespace cgreen;`
      at the beginning of the file with your tests
  
  There is also one extra feature when you use C++, the `assert_throws`
  function.
  
  
  === No fork, please
  
  *Cgreen* protects itself from being torn down by an exception in a
  test by `fork()`-ing each test into a separate process. A
  catastrophic error will then only affect the child process and 
  *Cgreen* can catch it, rather than crashing too. It can then report 
  the exception and continue with the next test.
  
  If you want to debug any of your tests the constant `fork()`-ing
  might make that difficult or impossible. There are also other 
  circumstances that might require that you don't use `fork()`.
  
  There are two ways to make *Cgreen* refrain from `fork()`-ing.
  
  *Cgreen* does not `fork()` when only a single test is run by name 
  with the function `run_single_test()`. To debug you can obviously set
  a breakpoint at that test (but note that its actual name probably 
  have been mangled). But since *Cgreen* does some book-keeping before 
  actually getting to the test, a better function is the one simply 
  called `run()`.
  
  The second way is to define the environment variable 
  `CGREEN_NO_FORK`. If *Cgreen* can get that variabel from the 
  environment using `getenv()` it will run the test(s) in the same 
  process.
  
  NOTE: This might bring your whole test suite down if a single test 
  causes an exception. So it is not a recommended setting for normal 
  use.
  
  
  
  