Add test for references in comments

pkg/analysis_server/test/analysis/notification_navigation_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.analysis.notification.navigation;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 import 'package:unittest/unittest.dart';
 
 import '../analysis_abstract.dart';
 
 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
 class AnalysisNotificationNavigationTest extends AbstractNavigationTest {
   Future prepareNavigation() {
     addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
     return waitForTasksFinished().then((_) {
       assertRegionsSorted();
     });
   }
 
   void processNotification(Notification notification) {
@@ skipping 257 matching lines @@
   int aaa = 42;
   print(aaa);
 }
 import 'dart:math';
 ''');
     return prepareNavigation().then((_) {
       assertHasRegionTarget('aaa);', 'aaa = 42');
     });
   }
 
+  test_inComment() async {
+    addTestFile('''
+class FirstClass {}
+class SecondClass {
+  /**
+   * Return a [FirstClass] object equivalent to this object in every other way.
+   */
+  convert() {
+    return new FirstClass();
+  }
+}
+''');
+    await prepareNavigation();
+    assertHasRegionTarget('FirstClass]', 'FirstClass {');
+    assertHasRegionTarget('FirstClass(', 'FirstClass {');
+  }
+
   test_instanceCreation_implicit() {
     addTestFile('''
 class A {
 }
 main() {
   new A();
 }
 ''');
     return prepareNavigation().then((_) {
       assertHasRegionString('A()', 'A'.length);
@@ skipping 323 matching lines @@
   test_type_void() {
     addTestFile('''
 void main() {
 }
 ''');
     return prepareNavigation().then((_) {
       assertNoRegionAt('void');
     });
   }
 }
-
-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')}');
-    }
-  }
-}