Fix summary_test.dart on Windows.

pkg/analyzer/test/src/summary/summary_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 'dart:typed_data';
 
 import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/builder.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart'
     as summarize_elements;
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../reflective_tests.dart';
 
@@ skipping 68 matching lines @@
    * that summaries need, so that this flag is no longer needed.
    */
   bool get checkAstDerivedData;
 
   /**
    * Get access to the "unlinked" section of the summary.
    */
   UnlinkedLibrary get unlinked => lib.unlinked;
 
   /**
+   * Convert [path] to a suitably formatted absolute path URI for the current
+   * platform.
+   */
+  String absUri(String path) {
+    return FileUtilities2.createFile(path).toURI().toString();
+  }
+
+  /**
    * Add the given source file so that it may be referenced by the file under
    * test.
    */
   addNamedSource(String filePath, String contents);
 
   /**
    * Verify that the [combinatorName] correctly represents the given [expected]
    * name.
    */
   void checkCombinatorName(
@@ skipping 130 matching lines @@
   }
 
   fail_test_import_missing() {
     // TODO(paulberry): At the moment unresolved imports are not included in
     // the element model, so we can't pass this test.
     // Unresolved imports are included since this is necessary for proper
     // dependency tracking.
     serializeLibraryText('import "foo.dart";', allowErrors: true);
     // Second import is the implicit import of dart:core
     expect(unlinked.imports, hasLength(2));
-    checkDependency(lib.importDependencies[0], 'file:///foo.dart', 'foo.dart');
+    checkDependency(lib.importDependencies[0], absUri('/foo.dart'), 'foo.dart');
   }
 
   /**
    * Find the class with the given [className] in the summary, and return its
    * [UnlinkedClass] data structure.
    */
   UnlinkedClass findClass(String className, {bool failIfAbsent: false}) {
     UnlinkedClass result;
     for (UnlinkedClass cls in unlinked.classes) {
       if (cls.name == className) {
@@ skipping 513 matching lines @@
       checkParamTypeRef(typeRef, 1);
     }
   }
 
   test_dependencies_export_none() {
     // Exports are not listed as dependencies since no change to the exported
     // file can change the summary of the exporting file.
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b;');
     serializeLibraryText('export "a.dart";');
-    checkLacksDependency('file:///a.dart', 'a.dart');
-    checkLacksDependency('file:///b.dart', 'b.dart');
+    checkLacksDependency(absUri('/a.dart'), 'a.dart');
+    checkLacksDependency(absUri('/b.dart'), 'b.dart');
   }
 
   test_dependencies_import_to_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b;');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('file:///a.dart', 'a.dart');
+    checkHasDependency(absUri('/a.dart'), 'a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency('file:///b.dart', 'b.dart');
+    checkHasDependency(absUri('/b.dart'), 'b.dart');
   }
 
   test_dependencies_import_to_export_in_subdirs_absolute_export() {
-    addNamedSource('/a/a.dart', 'library a; export "/a/b/b.dart"; class A {}');
+    addNamedSource('/a/a.dart',
+        'library a; export "${absUri('/a/b/b.dart')}"; class A {}');
     addNamedSource('/a/b/b.dart', 'library b;');
     serializeLibraryText('import "a/a.dart"; A a;');
-    checkHasDependency('file:///a/a.dart', 'a/a.dart');
+    checkHasDependency(absUri('/a/a.dart'), 'a/a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency('file:///a/b/b.dart', '/a/b/b.dart');
+    checkHasDependency(absUri('/a/b/b.dart'), '/a/b/b.dart');
   }
 
   test_dependencies_import_to_export_in_subdirs_absolute_import() {
     addNamedSource('/a/a.dart', 'library a; export "b/b.dart"; class A {}');
     addNamedSource('/a/b/b.dart', 'library b;');
-    serializeLibraryText('import "/a/a.dart"; A a;');
-    checkHasDependency('file:///a/a.dart', '/a/a.dart');
+    serializeLibraryText('import "${absUri('/a/a.dart')}"; A a;');
+    checkHasDependency(absUri('/a/a.dart'), '/a/a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency('file:///a/b/b.dart', '/a/b/b.dart');
+    checkHasDependency(absUri('/a/b/b.dart'), '/a/b/b.dart');
   }
 
   test_dependencies_import_to_export_in_subdirs_relative() {
     addNamedSource('/a/a.dart', 'library a; export "b/b.dart"; class A {}');
     addNamedSource('/a/b/b.dart', 'library b;');
     serializeLibraryText('import "a/a.dart"; A a;');
-    checkHasDependency('file:///a/a.dart', 'a/a.dart');
+    checkHasDependency(absUri('/a/a.dart'), 'a/a.dart');
     // The main test library depends on b.dart, because names defined in
     // b.dart are exported by a.dart.
-    checkHasDependency('file:///a/b/b.dart', 'a/b/b.dart');
+    checkHasDependency(absUri('/a/b/b.dart'), 'a/b/b.dart');
   }
 
   test_dependencies_import_to_export_loop() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b; export "a.dart";');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('file:///a.dart', 'a.dart');
+    checkHasDependency(absUri('/a.dart'), 'a.dart');
     // Serialization should have been able to walk the transitive export
     // dependencies to b.dart without going into an infinite loop.
-    checkHasDependency('file:///b.dart', 'b.dart');
+    checkHasDependency(absUri('/b.dart'), 'b.dart');
   }
 
   test_dependencies_import_to_export_transitive_closure() {
     addNamedSource('/a.dart', 'library a; export "b.dart"; class A {}');
     addNamedSource('/b.dart', 'library b; export "c.dart";');
     addNamedSource('/c.dart', 'library c;');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('file:///a.dart', 'a.dart');
+    checkHasDependency(absUri('/a.dart'), 'a.dart');
     // The main test library depends on c.dart, because names defined in
     // c.dart are exported by b.dart and then re-exported by a.dart.
-    checkHasDependency('file:///c.dart', 'c.dart');
+    checkHasDependency(absUri('/c.dart'), 'c.dart');
   }
 
   test_dependencies_import_transitive_closure() {
     addNamedSource(
         '/a.dart', 'library a; import "b.dart"; class A extends B {}');
     addNamedSource('/b.dart', 'library b; class B {}');
     serializeLibraryText('import "a.dart"; A a;');
-    checkHasDependency('file:///a.dart', 'a.dart');
+    checkHasDependency(absUri('/a.dart'), 'a.dart');
     // The main test library doesn't depend on b.dart, because no change to
     // b.dart can possibly affect the serialized element model for it.
-    checkLacksDependency('file:///b.dart', 'b.dart');
+    checkLacksDependency(absUri('/b.dart'), 'b.dart');
   }
 
   test_elements_in_part() {
     addNamedSource(
         '/part1.dart',
         '''
 part of my.lib;
 
 class C {}
 enum E { v }
@@ skipping 349 matching lines @@
     serializeLibraryText(
         'import "dart:async" as a; main() { print(a.Future); }');
     expect(unlinked.imports[0].isDeferred, isFalse);
   }
 
   test_import_of_file_with_missing_part() {
     // Other references in foo.dart should be resolved even though foo.dart's
     // part declaration for bar.dart refers to a non-existent file.
     addNamedSource('/foo.dart', 'part "bar.dart"; class C {}');
     serializeLibraryText('import "foo.dart"; C x;');
-    checkTypeRef(findVariable('x').type, 'file:///foo.dart', 'foo.dart', 'C');
+    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
   }
 
   test_import_of_missing_export() {
     // Other references in foo.dart should be resolved even though foo.dart's
     // re-export of bar.dart refers to a non-existent file.
     addNamedSource('/foo.dart', 'export "bar.dart"; class C {}');
     serializeLibraryText('import "foo.dart"; C x;');
-    checkTypeRef(findVariable('x').type, 'file:///foo.dart', 'foo.dart', 'C');
+    checkTypeRef(findVariable('x').type, absUri('/foo.dart'), 'foo.dart', 'C');
   }
 
   test_import_offset() {
     String libraryText = '    import "dart:async"; Future x;';
     serializeLibraryText(libraryText);
     expect(unlinked.imports[0].offset, libraryText.indexOf('import'));
   }
 
   test_import_prefix_name() {
     String libraryText = 'import "dart:async" as a; a.Future x;';
@@ skipping 191 matching lines @@
       UnlinkedTypeRef typeRef =
           findVariable('u', cls: cls, failIfAbsent: true).type;
       checkParamTypeRef(typeRef, 1);
     }
   }
 
   test_type_reference_to_import_of_export() {
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b; class C {}');
     checkTypeRef(serializeTypeText('C', otherDeclarations: 'import "a.dart";'),
-        'file:///b.dart', 'b.dart', 'C');
+        absUri('/b.dart'), 'b.dart', 'C');
   }
 
   test_type_reference_to_import_of_export_via_prefix() {
     addNamedSource('/a.dart', 'library a; export "b.dart";');
     addNamedSource('/b.dart', 'library b; class C {}');
     checkTypeRef(
         serializeTypeText('p.C', otherDeclarations: 'import "a.dart" as p;'),
-        'file:///b.dart',
+        absUri('/b.dart'),
         'b.dart',
         'C',
         expectedPrefix: 'p');
   }
 
   test_type_reference_to_imported_part() {
     addNamedSource('/a.dart', 'library my.lib; part "b.dart";');
     addNamedSource('/b.dart', 'part of my.lib; class C {}');
     checkTypeRef(
         serializeTypeText('C',
             otherDeclarations: 'library my.lib; import "a.dart";'),
-        'file:///a.dart',
+        absUri('/a.dart'),
         'a.dart',
         'C');
   }
 
   test_type_reference_to_imported_part_with_prefix() {
     addNamedSource('/a.dart', 'library my.lib; part "b.dart";');
     addNamedSource('/b.dart', 'part of my.lib; class C {}');
     checkTypeRef(
         serializeTypeText('p.C',
             otherDeclarations: 'library my.lib; import "a.dart" as p;'),
-        'file:///a.dart',
+        absUri('/a.dart'),
         'a.dart',
         'C',
         expectedPrefix: 'p');
   }
 
   test_type_reference_to_internal_class() {
     checkTypeRef(serializeTypeText('C', otherDeclarations: 'class C {}'), null,
         null, 'C');
   }
 
@@ skipping 35 matching lines @@
 
   test_type_unit_counts_unreferenced_units() {
     addNamedSource('/a.dart', 'library a; part "b.dart"; part "c.dart";');
     addNamedSource('/b.dart', 'part of a;');
     addNamedSource('/c.dart', 'part of a; class C {}');
     UnlinkedTypeRef typeRef =
         serializeTypeText('C', otherDeclarations: 'import "a.dart";');
     // The referenced unit should be 2, since unit 0 is a.dart and unit 1 is
     // b.dart.  a.dart and b.dart are counted even though nothing is imported
     // from them.
-    checkTypeRef(typeRef, 'file:///a.dart', 'a.dart', 'C');
+    checkTypeRef(typeRef, absUri('/a.dart'), 'a.dart', 'C');
   }
 
   test_type_unresolved() {
     UnlinkedTypeRef typeRef = serializeTypeText('Foo', allowErrors: true);
     checkUnresolvedTypeRef(typeRef, null, 'Foo');
   }
 
   test_typedef_name() {
     UnlinkedTypedef type = serializeTypedefText('typedef F();');
     expect(type.name, 'F');
@@ skipping 107 matching lines @@
         serializeClassText('class C { static int i; }').fields[0];
     expect(variable.isStatic, isTrue);
   }
 
   test_variable_type() {
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 }