Compute public namespace during resynthesizing.

pkg/analyzer/test/src/summary/resynthesize_test.dart

 // Copyright (c) 2015, 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.src.serialization.elements_test;
 
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/resolver.dart' show Namespace;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/resynthesize.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../reflective_tests.dart';
 
 main() {
@@ skipping 44 matching lines @@
           'export ${original.exports[i].uri}');
     }
     expect(resynthesized.nameLength, original.nameLength);
     if (original.entryPoint == null) {
       expect(resynthesized.entryPoint, isNull);
     } else {
       expect(resynthesized.entryPoint, isNotNull);
       compareFunctionElements(
           resynthesized.entryPoint, original.entryPoint, '(entry point)');
     }
-    // TODO(paulberry): test exportNamespace, publicNamespace,
-    // and metadata.
+    compareNamespaces(resynthesized.publicNamespace, original.publicNamespace,
+        '(public namespace)');
+    // TODO(paulberry): test exportNamespace and metadata.
   }
 
   void compareClassElements(
       ClassElementImpl resynthesized, ClassElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
     expect(resynthesized.fields.length, original.fields.length,
         reason: '$desc fields.length');
     for (int i = 0; i < resynthesized.fields.length; i++) {
       String name = original.fields[i].name;
       compareFieldElements(resynthesized.getField(name), original.fields[i],
@@ skipping 224 matching lines @@
         resynthesized is HideElementCombinatorImpl) {
       expect(resynthesized.hiddenNames, original.hiddenNames);
     } else if (resynthesized.runtimeType != original.runtimeType) {
       fail(
           'Type mismatch: expected ${original.runtimeType}, got ${resynthesized.runtimeType}');
     } else {
       fail('Unimplemented comparison for ${original.runtimeType}');
     }
   }
 
+  void compareNamespaces(
+      Namespace resynthesized, Namespace original, String desc) {
+    Map<String, Element> resynthesizedMap = resynthesized.definedNames;
+    Map<String, Element> originalMap = original.definedNames;
+    expect(resynthesizedMap.keys, originalMap.keys, reason: desc);

[Paul Berry, 2016/01/11 22:27:24]

I'd rather not rely on the keys being in the same order.  Let's do this instead:

expect(resynthesizedMap.keys.toSet(), originalMap.keys.toSet(), reason: desc);

+    for (String key in originalMap.keys) {
+      Element resynthesizedElement = resynthesizedMap[key];
+      Element originalElement = originalMap[key];
+      compareElements(resynthesizedElement, originalElement, key);
+    }
+  }
+
   void compareParameterElements(ParameterElementImpl resynthesized,
       ParameterElementImpl original, String desc) {
     compareVariableElements(resynthesized, original, desc);
     expect(resynthesized.parameters.length, original.parameters.length);
     for (int i = 0; i < resynthesized.parameters.length; i++) {
       compareParameterElements(
           resynthesized.parameters[i],
           original.parameters[i],
           '$desc parameter ${original.parameters[i].name}');
     }
@@ skipping 1026 matching lines @@
   }
 
   test_variable_implicit_type() {
     checkLibrary('var x;');
   }
 
   test_variables() {
     checkLibrary('int i; int j;');
   }
 }