anchor.diff:      });
     }
   }
  -
  -class AbstractNavigationTest extends AbstractAnalysisTest {
  -  List<NavigationRegion> regions;
  -  List<NavigationTarget> targets;
  -  List<String> targetFiles;
  -
  -  NavigationRegion testRegion;
  -  List<int> testTargetIndexes;
  -  NavigationTarget testTarget;
  -
  -  /**
  -   * Validates that there is a target in [testTargetIndexes] with [file],
  -   * at [offset] and with the given [length].
  -   */
  -  void assertHasFileTarget(String file, int offset, int length) {
  -    List<NavigationTarget> testTargets =
  -        testTargetIndexes.map((int index) => targets[index]).toList();
  -    for (NavigationTarget target in testTargets) {
  -      if (targetFiles[target.fileIndex] == file &&
  -          target.offset == offset &&
  -          target.length == length) {
  -        testTarget = target;
  -        return;
  -      }
  -    }
  -    fail(
  -        'Expected to find target (file=$file; offset=$offset; length=$length) in\n'
  -        '${testRegion} in\n' '${testTargets.join('\n')}');
  -  }
  -
  -  void assertHasOperatorRegion(String regionSearch, int regionLength,
  -      String targetSearch, int targetLength) {
  -    assertHasRegion(regionSearch, regionLength);
  -    assertHasTarget(targetSearch, targetLength);
  -  }
  -
  -  /**
  -   * Validates that there is a region at the offset of [search] in [testFile].
  -   * If [length] is not specified explicitly, then length of an identifier
  -   * from [search] is used.
  -   */
  -  void assertHasRegion(String search, [int length = -1]) {
  -    int offset = findOffset(search);
  -    if (length == -1) {
  -      length = findIdentifierLength(search);
  -    }
  -    findRegion(offset, length, true);
  -  }
  -
  -  /**
  -   * Validates that there is a region at the offset of [search] in [testFile]
  -   * with the given [length] or the length of [search].
  -   */
  -  void assertHasRegionString(String search, [int length = -1]) {
  -    int offset = findOffset(search);
  -    if (length == -1) {
  -      length = search.length;
  -    }
  -    findRegion(offset, length, true);
  -  }
  -
  -  /**
  -   * Validates that there is an identifier region at [regionSearch] with target
  -   * at [targetSearch].
  -   */
  -  void assertHasRegionTarget(String regionSearch, String targetSearch) {
  -    assertHasRegion(regionSearch);
  -    assertHasTarget(targetSearch);
  -  }
  -
  -  /**
  -   * Validates that there is a target in [testTargets]  with [testFile], at the
  -   * offset of [search] in [testFile], and with the given [length] or the length
  -   * of an leading identifier in [search].
  -   */
  -  void assertHasTarget(String search, [int length = -1]) {
  -    int offset = findOffset(search);
  -    if (length == -1) {
  -      length = findIdentifierLength(search);
  -    }
  -    assertHasFileTarget(testFile, offset, length);
  -  }
  -
  -  /**
  -   * Validates that there is no a region at [search] and with the given
  -   * [length].
  -   */
  -  void assertNoRegion(String search, int length) {
  -    int offset = findOffset(search);
  -    findRegion(offset, length, false);
  -  }
  -
  -  /**
  -   * Validates that there is no a region at [search] with any length.
  -   */
  -  void assertNoRegionAt(String search) {
  -    int offset = findOffset(search);
  -    findRegion(offset, -1, false);
  -  }
  -
  -  /**
  -   * Validates that there is no a region for [search] string.
  -   */
  -  void assertNoRegionString(String search) {
  -    int offset = findOffset(search);
  -    int length = search.length;
  -    findRegion(offset, length, false);
  -  }
  -
  -  void assertRegionsSorted() {
  -    int lastEnd = -1;
  -    for (NavigationRegion region in regions) {
  -      int offset = region.offset;
  -      if (offset < lastEnd) {
  -        fail('$lastEnd was expected to be > $offset in\n' + regions.join('\n'));
  -      }
  -      lastEnd = offset + region.length;
  -    }
  -  }
  -
  -  /**
  -   * Finds the navigation region with the given [offset] and [length].
  -   * If [length] is `-1`, then it is ignored.
  -   *
  -   * If [exists] is `true`, then fails if such region does not exist.
  -   * Otherwise remembers this it into [testRegion].
  -   * Also fills [testTargets] with its targets.
  -   *
  -   * If [exists] is `false`, then fails if such region exists.
  -   */
  -  void findRegion(int offset, int length, bool exists) {
  -    for (NavigationRegion region in regions) {
  -      if (region.offset == offset &&
  -          (length == -1 || region.length == length)) {
  -        if (exists == false) {
  -          fail('Not expected to find (offset=$offset; length=$length) in\n'
  -              '${regions.join('\n')}');
  -        }
  -        testRegion = region;
  -        testTargetIndexes = region.targets;
  -        return;
  -      }
  -    }
  -    if (exists == true) {
  -      fail('Expected to find (offset=$offset; length=$length) in\n'
  -          '${regions.join('\n')}');
  -    }
  -  }
  -}
  
positive.code:     return prepareNavigation().then((_) {
        assertHasRegionTarget('aaa);', 'aaa = 42');
      });
    }
  
    test_instanceCreation_implicit() {
  
negative.code: main() {
    groupSep = ' | ';
    defineReflectiveTests(AnalysisNotificationNavigationTest);
  }
  
  class AbstractNavigationTest extends AbstractAnalysisTest {
    List<NavigationRegion> regions;
    List<NavigationTarget> targets;
    List<String> targetFiles;
  
    NavigationRegion testRegion;
    List<int> testTargetIndexes;
    NavigationTarget testTarget;
  
    /**
     * Validates that there is a target in [testTargetIndexes] with [file],
     * at [offset] and with the given [length].
     */
    void assertHasFileTarget(String file, int offset, int length) {
      List<NavigationTarget> testTargets =
          testTargetIndexes.map((int index) => targets[index]).toList();
      for (NavigationTarget target in testTargets) {
        if (targetFiles[target.fileIndex] == file &&
            target.offset == offset &&
            target.length == length) {
          testTarget = target;
          return;
        }
      }
      fail(
          'Expected to find target (file=$file; offset=$offset; length=$length) in\n'
          '${testRegion} in\n' '${testTargets.join('\n')}');
    }
  
    void assertHasOperatorRegion(String regionSearch, int regionLength,
        String targetSearch, int targetLength) {
      assertHasRegion(regionSearch, regionLength);
      assertHasTarget(targetSearch, targetLength);
    }
  
    /**
     * Validates that there is a region at the offset of [search] in [testFile].
     * If [length] is not specified explicitly, then length of an identifier
     * from [search] is used.
     */
    void assertHasRegion(String search, [int length = -1]) {
      int offset = findOffset(search);
      if (length == -1) {
        length = findIdentifierLength(search);
      }
      findRegion(offset, length, true);
    }
  
    /**
     * Validates that there is a region at the offset of [search] in [testFile]
     * with the given [length] or the length of [search].
     */
    void assertHasRegionString(String search, [int length = -1]) {
      int offset = findOffset(search);
      if (length == -1) {
        length = search.length;
      }
      findRegion(offset, length, true);
    }
  
    /**
     * Validates that there is an identifier region at [regionSearch] with target
     * at [targetSearch].
     */
    void assertHasRegionTarget(String regionSearch, String targetSearch) {
      assertHasRegion(regionSearch);
      assertHasTarget(targetSearch);
    }
  
    /**
     * Validates that there is a target in [testTargets]  with [testFile], at the
     * offset of [search] in [testFile], and with the given [length] or the length
     * of an leading identifier in [search].
     */
    void assertHasTarget(String search, [int length = -1]) {
      int offset = findOffset(search);
      if (length == -1) {
        length = findIdentifierLength(search);
      }
      assertHasFileTarget(testFile, offset, length);
    }
  
    /**
     * Validates that there is no a region at [search] and with the given
     * [length].
     */
    void assertNoRegion(String search, int length) {
      int offset = findOffset(search);
      findRegion(offset, length, false);
    }
  
    /**
     * Validates that there is no a region at [search] with any length.
     */
    void assertNoRegionAt(String search) {
      int offset = findOffset(search);
      findRegion(offset, -1, false);
    }
  
    /**
     * Validates that there is no a region for [search] string.
     */
    void assertNoRegionString(String search) {
      int offset = findOffset(search);
      int length = search.length;
      findRegion(offset, length, false);
    }
  
    void assertRegionsSorted() {
      int lastEnd = -1;
      for (NavigationRegion region in regions) {
        int offset = region.offset;
        if (offset < lastEnd) {
          fail('$lastEnd was expected to be > $offset in\n' + regions.join('\n'));
        }
        lastEnd = offset + region.length;
      }
    }
  
    /**
     * Finds the navigation region with the given [offset] and [length].
     * If [length] is `-1`, then it is ignored.
     *
     * If [exists] is `true`, then fails if such region does not exist.
     * Otherwise remembers this it into [testRegion].
     * Also fills [testTargets] with its targets.
     *
     * If [exists] is `false`, then fails if such region exists.
     */
    void findRegion(int offset, int length, bool exists) {
      for (NavigationRegion region in regions) {
        if (region.offset == offset &&
            (length == -1 || region.length == length)) {
          if (exists == false) {
            fail('Not expected to find (offset=$offset; length=$length) in\n'
                '${regions.join('\n')}');
          }
          testRegion = region;
          testTargetIndexes = region.targets;
          return;
        }
      }
      if (exists == true) {
        fail('Expected to find (offset=$offset; length=$length) in\n'
            '${regions.join('\n')}');
      }
    }
  }
  
  @reflectiveTest
  