anchor.diff:  
       A test may also contain nested tests.
   
  -    <code>
  -    D "outer test" do
  -      # assertions and logic here
  -
  -      D "inner test" do
  -        # more assertions and logic here
  -      end
  -    end
  -    </code>
  +        D "outer test" do
  +          # assertions and logic here
  +
  +          D "inner test" do
  +            # more assertions and logic here
  +          end
  +        end
  +
  +    {:lang=ruby}
   
   
       %|section "Hooks"
   
         The [`D()` method](<%= dfect_api %>) provides several entry points (hooks) into the test execution process:
   
  -      <code>
  -      D "outer test" do
  -        D .<  { puts "before each nested test" }
  -        D .>  { puts "after  each nested test" }
  -        D .<< { puts "before all nested tests" }
  -        D .>> { puts "after  all nested tests" }
  -
  -        D "inner test" do
  -          # assertions and logic here
  -        end
  -      end
  -      </code>
  +          D "outer test" do
  +            D .<  { puts "before each nested test" }
  +            D .>  { puts "after  each nested test" }
  +            D .<< { puts "before all nested tests" }
  +            D .>> { puts "after  all nested tests" }
  +
  +            D "inner test" do
  +              # assertions and logic here
  +            end
  +          end
  +
  +      {:lang=ruby}
   
         A hook method may be called multiple times.  Each call registers additional logic to execute during the hook:
   
  -      <code>
  -      D .< { puts "do something" }
  -      D .< { puts "do something more!" }
  -      </code>
  +          D .< { puts "do something" }
  +          D .< { puts "do something more!" }
  +
  +      {:lang=ruby}
   
   
       %|section "Insulation"
   
         Use the singleton class of a temporary object to shield your test logic from Ruby's global environment, the code being tested, and from other tests:
   
  -      <code>
  -      class << Object.new
  -        # your test logic here
  -      end
  -      </code>
  +          class << Object.new
  +            # your test logic here
  +          end
  +
  +      {:lang=ruby}
   
         Inside this insulated environment, you are free to:
         * mix-in any modules your test logic needs
  
positive.code: 
        When an assertion fails, details about the failure will be shown:
  
        <pre>
        - fail: block must yield true (!nil && !false)
          code: |-
            [12..22] in test/simple.rb
               12
               13     D "with more nested tests" do
               14       x = 5
               15
               16       T { x > 2 }   # passes
            => 17       F { x > 2 }   # fails
               18       E { x.hello } # passes
               19     end
               20   end
               21
               22   # equivalent of before(:each) or setup()
          vars:
            x: 5
            y: 83
          call:
          - test/simple.rb:17
          - test/simple.rb:3
        </pre>
  
        You will then be placed into a debugger to investigate the failure if the `:debug` option is enabled in [`Dfect.options`](<%= dfect_api %>).
  
  
negative.code: 
    Begin by loading <%= $project %> into your program:
  
        require 'rubygems'
        require 'dfect'
  
    {:lang=ruby}
  
    You now have access to the [`Dfect` module](<%= dfect_api %>), which provides mixin-able instance methods that are also directly-callable as class methods:
  
        Dfect.D "hello" do  # D() is a class method
          puts "world"
        end
  
        # the above is same as:
  
        include Dfect       # mix-in the Dfect API
  
        D "hello" do        # D() is an instance method
          puts "world"
        end
  
    {:lang=ruby}
  
    The following sections explain these provided methods in detail.
  
  