anchor.diff:    Notice that `fakeAsync` replaces `async` as the `it` argument.
     The `fakeAsync` function is another of the Angular testing utilities.
   
  -  Like [async](#), it _takes_ a parameterless function and _returns_ a parameterless function
  -  which becomes the argument to the  Jasmine `it` call. 
  +  Like [async](#async), it _takes_ a parameterless function and _returns_ a function
  +  that becomes the argument to the  Jasmine `it` call. 
   
     The `fakeAsync` function enables a linear coding style by running the test body in a special _fakeAsync test zone_.
   
     The principle advantage of `fakeAsync` over `async` is that the test appears to be synchronous.
  -  There are no promises at all. 
  -  No `then(...)` chains to disrupt the visible flow of control.
  -
  -  There are limitations. For example, you cannot make an XHR call from within a `fakeAsync`.
  +  There is no `then(...)` to disrupt the visible flow of control.
  +  The promise-returning `fixture.whenStable` is gone, replaced by `tick()`.
  +
  +.l-sub-section
  +  :marked
  +    There _are_ limitations. For example, you cannot make an XHR call from within a `fakeAsync`.
   
   #tick
   #tick-first-look
   :marked
     ## The _tick_ function
  -  Compare the third and fourth tests. Notice that `fixture.whenStable` is gone, replaced by `tick()`.
  -
     The `tick` function is one of the Angular testing utilities and a companion to `fakeAsync`.
     It can only be called within a `fakeAsync` body.
   
  
positive.code:   which intercepts all promises issued within the _async_ method call.
    
    The `ComponentFixture.whenStable` method returns its own promise which resolves when the `getQuote` promise completes.
    In fact, the _whenStable_ promise resolves when _all pending asynchronous activities_ complete ... the definition of "stable".
  
    Then the testing continues. 
    The test kicks off another round of change detection (`fixture.detechChanges`) which tells Angular to update the DOM with the quote.
    The `getQuote` helper method extracts the display element text and the expectation confirms that the text matches the test quote.
  
  #fakeAsync
  
negative.code: :marked
    ## The _async_ function in _beforeEach_
  
    Notice the `async` call in the `beforeEach`, made necessary by the asynchronous `TestBed.compileComponents` method.
    The `async` function arranges for the tester's code to run in a special _async test zone_
    that hides the mechanics of asynchronous execution, just as it does when passed to an [_it_ test)(#async).
  
  #compile-components
  :marked
    ## _compileComponents_ 
    In this example, `TestBed.compileComponents` compiles one component, the `DashboardComponent`. 
    It's the only declared component in this testing module.
  
    Tests later in this chapter have more declared components and some of them import application
    modules that declare yet more components.
    Some or all of these components could have external templates and css files.
    `TestBed.compileComponents` compiles them all asynchronously at one time.
    
    The `compileComponents` method returns a promise so you can perform additional tasks _after_ it finishes.
    The promise isn't needed here.
  
    ### _compileComponents_ closes configuration
    Calling `compileComponents` closes the current `TestBed` instance is further configuration.
    You cannot call any more `TestBed` configuration methods, not `configureTestModule` 
    nor any of the `override...` methods. The `TestBed` throws an error if you try.
  
  