Split computers.dart and use parsed JSON objects for navigation tests.

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.domain.analysis.notification.navigation;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 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() {
   group('notification.navigation', () {
     runReflectiveTests(AnalysisNotificationNavigationTest);
   });
 }
 
 
 @ReflectiveTestCase()
 class AnalysisNotificationNavigationTest extends AbstractAnalysisTest {
-  List<Map<String, Object>> regions;
-  Map<String, Object> testRegion;
-  List<Map<String, Object>> testTargets;
+  List<_NavigationRegion> regions;
+  _NavigationRegion testRegion;
+  List<_NavigationTarget> testTargets;
 
   void processNotification(Notification notification) {
     if (notification.event == NOTIFICATION_NAVIGATION) {
       String file = notification.getParameter(FILE);
       if (file == testFile) {
-        regions = notification.getParameter(REGIONS);
+        regions = [];
+        List<Map<String, Object>> regionsJson = notification.getParameter(REGIONS);
+        for (Map<String, Object> regionJson in regionsJson) {
+          var regionOffset = regionJson['offset'];
+          var regionLength = regionJson['length'];
+          List<_NavigationTarget> targets = [];
+          for (Map<String, Object> targetJson in regionJson['targets']) {
+            var targetFile = targetJson['file'];
+            var targetOffset = targetJson['offset'];
+            var targetLength = targetJson['length'];
+            targets.add(new _NavigationTarget(targetFile, targetOffset, targetLength));
+          }
+          var region = new _NavigationRegion(regionOffset, regionLength, targets);
+          regions.add(region);
+        }
       }
     }
   }
 
   Future prepareNavigation(then()) {
     addAnalysisSubscription(AnalysisService.NAVIGATION, testFile);
     return waitForTasksFinished().then((_) {
       then();
     });
   }
 
   /**
    * 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 (Map<String, Object> region in regions) {
-      if (region['offset'] == offset &&
-          (length == -1 || region['length'] == length)) {
+    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'];
+        testTargets = region.targets;
         return;
       }
     }
     if (exists == true) {
       fail('Expected to find (offset=$offset; length=$length) in\n'
            '${regions.join('\n')}');
     }
   }
 
   /**
@@ skipping 22 matching lines @@
   /**
    * 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);
     }
-    for (Map<String, Object> target in testTargets) {
-      if (target['file'] == testFile &&
-          target['offset'] == offset &&
-          target['length'] == length) {
-        return;
-      }
-    }
-    fail('Expected to find target (offset=$offset; length=$length) in\n'
-         '${testRegion} in\n'
-         '${regions.join('\n')}');
+    assertHasFileTarget(testFile, offset, length);
   }
 
   /**
    * Validates that there is a target in [testTargets]  with [file], at [offset]
    * and with the given [length].
    */
   void assertHasFileTarget(String file, int offset, int length) {
-    for (Map<String, Object> target in testTargets) {
-      if (target['file'] == file &&
-          target['offset'] == offset &&
-          target['length'] == length) {
+    for (_NavigationTarget target in testTargets) {
+      if (target.file == file &&
+          target.offset == offset &&
+          target.length == length) {
         return;
       }
     }
     fail('Expected to find target (file=$file; offset=$offset; length=$length) in\n'
          '${testRegion} in\n'
          '${regions.join('\n')}');
   }
 
   /**
    * Validates that there is an identifier region at [regionSearch] with target
@@ skipping 285 matching lines @@
     // This Source/File does not exist.
 //    addTestFile('''
 //library lib;
 //part "test_unit.dart";
 //''');
 //    return prepareNavigation(() {
 //      assertNoRegionString('part "test_unit.dart"');
 //    });
   }
 }
+
+
+class _NavigationRegion {
+  final int offset;
+  final int length;
+  final List<_NavigationTarget> targets;
+
+  _NavigationRegion(this.offset, this.length, this.targets);
+}
+
+
+class _NavigationTarget {
+  final String file;
+  final int offset;
+  final int length;
+
+  _NavigationTarget(this.file, this.offset, this.length);
+}