Compressed/optimized navigation notification.

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:unittest/unittest.dart';
 
 import '../analysis_abstract.dart';
 import '../reflective_tests.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisNotificationNavigationTest);
 }
 
 
 @ReflectiveTestCase()
 class AnalysisNotificationNavigationTest extends AbstractAnalysisTest {
   List<NavigationRegion> regions;
+  List<NavigationTarget> targets;
+  List<String> targetFiles;
+
   NavigationRegion testRegion;
-  List<Element> testTargets;
-  Element testTarget;
+  List<int> testTargetIndexes;
+  NavigationTarget testTarget;
 
   /**
-   * Validates that there is a target in [testTargets]  with [file], at [offset]
-   * and with the given [length].
+   * 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) {
-    for (Element target in testTargets) {
-      Location location = target.location;
-      if (location.file == file &&
-          location.offset == offset &&
-          location.length == 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,
@@ skipping 99 matching lines @@
   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;
-        testTargets = region.targets;
+        testTargetIndexes = region.targets;
         return;
       }
     }
     if (exists == true) {
       fail(
           'Expected to find (offset=$offset; length=$length) in\n'
               '${regions.join('\n')}');
     }
   }
 
   Future prepareNavigation() {
     addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
     return waitForTasksFinished().then((_) {
       assertRegionsSorted();
     });
   }
 
   void processNotification(Notification notification) {
     if (notification.event == ANALYSIS_NAVIGATION) {
       var params = new AnalysisNavigationParams.fromNotification(notification);
       if (params.file == testFile) {
         regions = params.regions;
+        targets = params.targets;
+        targetFiles = params.files;
       }
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     createProject();
   }
 
   test_afterAnalysis() {
     addTestFile('''
 class AAA {}
 AAA aaa;
 ''');
     return waitForTasksFinished().then((_) {
       return prepareNavigation().then((_) {
         assertHasRegionTarget('AAA aaa;', 'AAA {}');
       });
     });
   }
 
   test_class_fromSDK() {
     addTestFile('''
 int V = 42;
 ''');
     return prepareNavigation().then((_) {
       assertHasRegion('int V');
-      Element target = testTargets[0];
-      Location location = target.location;
-      expect(location.startLine, greaterThan(0));
-      expect(location.startColumn, greaterThan(0));
+      int targetIndex = testTargetIndexes[0];
+      NavigationTarget target = targets[targetIndex];
+      expect(target.startLine, greaterThan(0));
+      expect(target.startColumn, greaterThan(0));
     });
   }
 
   test_constructor_named() {
     addTestFile('''
 class A {
   A.named(BBB p) {}
 }
 class BBB {}
 ''');
@@ skipping 354 matching lines @@
   test_targetElement() {
     addTestFile('''
 class AAA {}
 main() {
   AAA aaa = null;
 }
 ''');
     return prepareNavigation().then((_) {
       assertHasRegionTarget('AAA aaa', 'AAA {}');
       expect(testTarget.kind, ElementKind.CLASS);
-      expect(testTarget.name, 'AAA');
-      expect(testTarget.isAbstract, false);
-      expect(testTarget.parameters, isNull);
-      expect(testTarget.returnType, isNull);
     });
   }
 
   test_type_dynamic() {
     addTestFile('''
 main() {
   dynamic v = null;
 }
 ''');
     return prepareNavigation().then((_) {
       assertNoRegionAt('dynamic');
     });
   }
 
   test_type_void() {
     addTestFile('''
 void main() {
 }
 ''');
     return prepareNavigation().then((_) {
       assertNoRegionAt('void');
     });
   }
 }