Make common tests consistent

pkg/analysis_server/test/services/completion/dart/type_member_contributor_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.
 
 import 'dart:async';
 
 import 'package:analysis_server/src/provisional/completion/dart/completion_dart.dart';
 import 'package:analysis_server/src/services/completion/dart/type_member_contributor.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:test/test.dart';
@@ skipping 532 matching lines @@
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource(
         '/testH.dart',
         '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
-        import "/testAB.dart";
-        import "/testCD.dart" hide D;
-        import "/testEEF.dart" show EE;
-        import "/testG.dart" as g;
+        import "testAB.dart";
+        import "testCD.dart" hide D;
+        import "testEEF.dart" show EE;
+        import "testG.dart" as g;
         int T5;
         var _T6;
         String get T7 => 'hello';
         set T8(int value) { partT8() {} }
         Z D2() {int x;}
         class X {
           int get clog => 8;
           set blog(value) { }
           a() {
             var f;
@@ skipping 76 matching lines @@
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource(
         '/testH.dart',
         '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
-        import "/testAB.dart";
-        import "/testCD.dart" hide D;
-        import "/testEEF.dart" show EE;
-        import "/testG.dart" as g;
+        import "testAB.dart";
+        import "testCD.dart" hide D;
+        import "testEEF.dart" show EE;
+        import "testG.dart" as g;
         int T5;
         var _T6;
         String get T7 => 'hello';
         set T8(int value) { partT8() {} }
         Z D2() {int x;}
         class X {
           int get clog => 8;
           set blog(value) { }
           a() {
             var f;
@@ skipping 96 matching lines @@
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource(
         '/testH.dart',
         '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
-        import "/testAB.dart";
-        import "/testCD.dart" hide D;
-        import "/testEEF.dart" show EE;
-        import "/testG.dart" as g;
+        import "testAB.dart";
+        import "testCD.dart" hide D;
+        import "testEEF.dart" show EE;
+        import "testG.dart" as g;
         int T5;
         var _T6;
         String get T7 => 'hello';
         set T8(int value) { partT8() {} }
         Z D2() {int x;}
         class X {
           int get clog => 8;
           set blog(value) { }
           a() {
             final ^
@@ skipping 82 matching lines @@
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource(
         '/testH.dart',
         '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
-        import "/testAB.dart";
-        import "/testCD.dart" hide D;
-        import "/testEEF.dart" show EE;
-        import "/testG.dart" as g;
+        import "testAB.dart";
+        import "testCD.dart" hide D;
+        import "testEEF.dart" show EE;
+        import "testG.dart" as g;
         int T5;
         var _T6;
         String get T7 => 'hello';
         set T8(int value) { partT8() {} }
         Z D2() {int x;}
         class X {
           int get clog => 8;
           set blog(value) { }
           a() {
             final ^
@@ skipping 82 matching lines @@
         class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource(
         '/testH.dart',
         '''
         class H { }
         class D3 { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
-        import "/testAB.dart";
-        import "/testCD.dart" hide D;
-        import "/testEEF.dart" show EE;
-        import "/testG.dart" as g;
+        import "testAB.dart";
+        import "testCD.dart" hide D;
+        import "testEEF.dart" show EE;
+        import "testG.dart" as g;
         int T5;
         var _T6;
         Z D2() {int x;}
         class X {a() {var f; {var x;} D^ var r;} void b() { }}
         class Z { }''');
     await computeSuggestions();
 
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
 
@@ skipping 44 matching lines @@
     // Block  BlockFunctionBody  MethodDeclaration  ClassDeclaration
     addSource(
         '/testB.dart',
         '''
         lib B;
         class F { var f1; f2() { } get f3 => 0; set f4(fx) { } var _pf; }
         class E extends F { var e1; e2() { } }
         class I { int i1; i2() { } }
         class M { var m1; int m2() { } }''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class A extends E implements I with M {a() {^}}''');
     await computeSuggestions();
 
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // TODO (danrubel) prefer fields over getters
     // If add `get e1;` to interface I
     // then suggestions include getter e1 rather than field e1
     assertNotSuggested('e1');
     assertNotSuggested('f1');
@@ skipping 52 matching lines @@
         class EE { }
         class F { }''');
     addSource('/testG.dart', 'class G { }');
     addSource(
         '/testH.dart',
         '''
         class H { }
         int T3;
         var _T4;'''); // not imported
     addTestSource('''
-        import "/testAB.dart";
-        import "/testCD.dart" hide D;
-        import "/testEEF.dart" show EE;
-        import "/testG.dart" as g;
+        import "testAB.dart";
+        import "testCD.dart" hide D;
+        import "testEEF.dart" show EE;
+        import "testG.dart" as g;
         int T5;
         var _T6;
         String get T7 => 'hello';
         set T8(int value) { partT8() {} }
         Z D2() {int x;}
         class X {
           int get clog => 8;
           set blog(value) { }
           a() {
             var f;
             localF(int arg1) { }
             {var x;}
             p^ var r;
           }
           void b() { }}
         class Z { }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('partT8');
     assertNotSuggested('partBoo');
     assertNotSuggested('parseIPv6Address');
     assertNotSuggested('parseHex');
   }
 
   test_Block_unimported() async {
     addPackageSource('myBar', 'bar.dart', 'class Foo2 { Foo2() { } }');
     addSource(
         '/proj/testAB.dart', 'import "package:myBar/bar.dart"; class Foo { }');
-    testFile = '/proj/completionTest.dart';
+    testFile = provider.convertPath('/proj/completionTest.dart');
     addTestSource('class C {foo(){F^}}');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('Foo');
     // TODO(danrubel) implement
     assertNotSuggested('Foo2');
     assertNotSuggested('Future');
   }
 
   test_CascadeExpression_method1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource(
         '/testB.dart',
         '''
         class B { }''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class A {var b; X _c;}
         class X{}
         // looks like a cascade to the parser
         // but the user is trying to get completions for a non-cascade
         main() {A a; a.^.z()}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     assertNotSuggested('Object');
     assertNotSuggested('A');
     assertNotSuggested('B');
     assertNotSuggested('X');
     assertNotSuggested('z');
     assertNotSuggested('==');
   }
 
   test_CascadeExpression_selector1() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource(
         '/testB.dart',
         '''
         class B { }''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class A {var b; X _c;}
         class X{}
         // looks like a cascade to the parser
         // but the user is trying to get completions for a non-cascade
         main() {A a; a.^.z}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     assertNotSuggested('Object');
     assertNotSuggested('A');
     assertNotSuggested('B');
     assertNotSuggested('X');
     assertNotSuggested('z');
     assertNotSuggested('==');
   }
 
   test_CascadeExpression_selector2() async {
     // SimpleIdentifier  PropertyAccess  CascadeExpression  ExpressionStatement
     addSource(
         '/testB.dart',
         '''
         class B { }''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class A {var b; X _c;}
         class X{}
         main() {A a; a..^z}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 1);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     assertNotSuggested('Object');
     assertNotSuggested('A');
     assertNotSuggested('B');
     assertNotSuggested('X');
     assertNotSuggested('z');
     assertNotSuggested('==');
   }
 
   test_CascadeExpression_selector2_withTrailingReturn() async {
     // PropertyAccess  CascadeExpression  ExpressionStatement  Block
     addSource(
         '/testB.dart',
         '''
         class B { }''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class A {var b; X _c;}
         class X{}
         main() {A a; a..^ return}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestField('b', null);
     assertSuggestField('_c', 'X');
     assertNotSuggested('Object');
     assertNotSuggested('A');
@@ skipping 211 matching lines @@
         part of libAB;
         var T1;
         PB F1() => new PB();
         class PB { }''');
     addSource(
         '/testCD.dart',
         '''
         class C { }
         class D { }''');
     addTestSource('''
-        import "/testAB.dart" hide ^;
-        import "/testCD.dart";
+        import "testAB.dart" hide ^;
+        import "testCD.dart";
         class X {}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_Combinator_show() async {
     // SimpleIdentifier  HideCombinator  ImportDirective
     addSource(
         '/testAB.dart',
         '''
         library libAB;
         part '/partAB.dart';
         class A { }
         class B { }''');
     addSource(
         '/partAB.dart',
         '''
         part of libAB;
         var T1;
         PB F1() => new PB();
         typedef PB2 F2(int blat);
         class Clz = Object with Object;
         class PB { }''');
     addSource(
         '/testCD.dart',
         '''
         class C { }
         class D { }''');
     addTestSource('''
-        import "/testAB.dart" show ^;
-        import "/testCD.dart";
+        import "testAB.dart" show ^;
+        import "testCD.dart";
         class X {}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_ConditionalExpression_elseExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T1 : T^}}''');
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_elseExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T1 : ^}}''');
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_partial_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T^}}''');
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_partial_thenExpression_empty() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? ^}}''');
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConditionalExpression_thenExpression() async {
     // SimpleIdentifier  ConditionalExpression  ReturnStatement
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} return a ? T^ : c}}''');
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_ConstructorName_importedClass() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addSource(
         '/testB.dart',
         '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         var m;
         main() {new X.^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by NamedConstructorContributor
     assertNotSuggested('c');
     assertNotSuggested('F1');
     assertNotSuggested('T1');
     assertNotSuggested('_d');
     assertNotSuggested('z');
     assertNotSuggested('m');
   }
 
   test_ConstructorName_importedFactory() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName  ConstructorName
     // InstanceCreationExpression
     addSource(
         '/testB.dart',
         '''
         lib B;
         int T1;
         F1() { }
         class X {factory X.c(); factory X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         var m;
         main() {new X.^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by NamedConstructorContributor
     assertNotSuggested('c');
     assertNotSuggested('F1');
     assertNotSuggested('T1');
     assertNotSuggested('_d');
@@ skipping 140 matching lines @@
 
   test_ExpressionStatement_identifier() async {
     // SimpleIdentifier  ExpressionStatement  Block
     addSource(
         '/testA.dart',
         '''
         _B F1() { }
         class A {int x;}
         class _B { }''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         typedef int F2(int blat);
         class Clz = Object with Object;
         class C {foo(){^} void bar() {}}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('F1');
     assertNotSuggested('C');
     assertNotSuggested('foo');
     assertNotSuggested('bar');
     assertNotSuggested('F2');
     assertNotSuggested('Clz');
     assertNotSuggested('C');
     assertNotSuggested('x');
     assertNotSuggested('_B');
   }
 
   test_ExpressionStatement_name() async {
     // ExpressionStatement  Block  BlockFunctionBody  MethodDeclaration
     addSource(
         '/testA.dart',
         '''
         B T1;
         class B{}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         class C {a() {C ^}}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_FieldDeclaration_name_typed() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // FieldDeclaration
     addSource('/testA.dart', 'class A { }');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         class C {A ^}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_FieldDeclaration_name_var() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // FieldDeclaration
     addSource('/testA.dart', 'class A { }');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         class C {var ^}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_FieldFormalParameter_in_non_constructor() async {
     // SimpleIdentifer  FieldFormalParameter  FormalParameterList
     addTestSource('class A {B(this.^foo) {}}');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
@@ skipping 137 matching lines @@
   test_FunctionDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         /* */ ^ zoo(z) { } String name;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
@@ skipping 10 matching lines @@
   test_FunctionDeclaration_returnType_afterComment2() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         /** */ ^ zoo(z) { } String name;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
@@ skipping 10 matching lines @@
   test_FunctionDeclaration_returnType_afterComment3() async {
     // FunctionDeclaration  ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         /// some dartdoc
         class C2 { }
         ^ zoo(z) { } String name;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
@@ skipping 149 matching lines @@
 
   test_IndexExpression() async {
     // ExpressionStatement  Block
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} f[^]}}''');
     await computeSuggestions();
     assertNotSuggested('x');
     assertNotSuggested('f');
     assertNotSuggested('foo');
     assertNotSuggested('C');
     assertNotSuggested('F2');
     assertNotSuggested('T2');
     assertNotSuggested('A');
     assertNotSuggested('F1');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_IndexExpression2() async {
     // SimpleIdentifier IndexExpression ExpressionStatement  Block
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         class B {int x;}
         class C {foo(){var f; {var x;} f[T^]}}''');
     await computeSuggestions();
     // top level results are partially filtered based on first char
     assertNotSuggested('T2');
     // TODO (danrubel) getter is being suggested instead of top level var
     //assertSuggestImportedTopLevelVar('T1', 'int');
   }
 
   test_InstanceCreationExpression_imported() async {
     // SimpleIdentifier  TypeName  ConstructorName  InstanceCreationExpression
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         class A {A(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         import "dart:async";
         int T2;
         F2() { }
         class B {B(this.x, [String boo]) { } int x;}
         class C {foo(){var f; {var x;} new ^}}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('Future');
@@ skipping 23 matching lines @@
   test_InterpolationExpression() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         main() {String name; print("hello \$^");}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     // TODO(danrubel) should return top level var rather than getter
@@ skipping 10 matching lines @@
   test_InterpolationExpression_block() async {
     // SimpleIdentifier  InterpolationExpression  StringInterpolation
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         main() {String name; print("hello \${^}");}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('F1');
@@ skipping 46 matching lines @@
 
   test_IsExpression() async {
     // SimpleIdentifier  TypeName  IsExpression  IfStatement
     addSource(
         '/testB.dart',
         '''
         lib B;
         foo() { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class Y {Y.c(); Y._d(); z() {}}
         main() {var x; if (x is ^) { }}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('x');
     assertNotSuggested('main');
     assertNotSuggested('foo');
@@ skipping 55 matching lines @@
   test_keyword2() async {
     addSource(
         '/testB.dart',
         '''
         lib B;
         int newT1;
         int T1;
         nowIsIt() { }
         class X {factory X.c(); factory X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         String newer() {}
         var m;
         main() {new^ X.c();}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 3);
     expect(replacementLength, 3);
     assertNotSuggested('c');
     assertNotSuggested('_d');
     // Imported suggestion are filtered by 1st character
     assertNotSuggested('nowIsIt');
@@ skipping 34 matching lines @@
     addTestSource('import "dart:async" deferred as bar; foo() {bar.^}');
     await computeSuggestions();
     // Suggested by LibraryMemberContributor
     assertNotSuggested('Future');
     assertNotSuggested('loadLibrary');
   }
 
   test_libraryPrefix_with_exports() async {
     addSource('/libA.dart', 'library libA; class A { }');
     addSource('/libB.dart', 'library libB; export "/libA.dart"; class B { }');
-    addTestSource('import "/libB.dart" as foo; main() {foo.^} class C { }');
+    addTestSource('import "libB.dart" as foo; main() {foo.^} class C { }');
     await computeSuggestions();
     // Suggested by LibraryMemberContributor
     assertNotSuggested('B');
     assertNotSuggested('A');
   }
 
   test_Literal_list() async {
     // ']'  ListLiteral  ArgumentList  MethodInvocation
     addTestSource('main() {var Some; print([^]);}');
     await computeSuggestions();
@@ skipping 44 matching lines @@
   test_MapLiteralEntry() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         foo = {^''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
   }
 
   test_MapLiteralEntry1() async {
     // MapLiteralEntry  MapLiteral  VariableDeclaration
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         foo = {T^''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('T2');
   }
 
   test_MapLiteralEntry2() async {
     // SimpleIdentifier  MapLiteralEntry  MapLiteral  VariableDeclaration
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 { }
         foo = {7:T^};''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('T2');
   }
@@ skipping 112 matching lines @@
     // Block  BlockFunctionBody  MethodDeclaration
     addSource(
         '/testC.dart',
         '''
         class C {
           c1() {}
           var c2;
           static c3() {}
           static var c4;}''');
     addTestSource('''
-        import "/testC.dart";
+        import "testC.dart";
         class B extends C {
           b1() {}
           var b2;
           static b3() {}
           static var b4;}
         class A extends B {
           a1() {}
           var a2;
           static a3() {}
           static var a4;
@@ skipping 59 matching lines @@
   test_MethodDeclaration_returnType() async {
     // ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment() async {
     // ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {/* */ ^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment2() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {/** */ ^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('T1');
     assertNotSuggested('F1');
     assertNotSuggested('D1');
     assertNotSuggested('C1');
     assertNotSuggested('T2');
     assertNotSuggested('F2');
     assertNotSuggested('D2');
     assertNotSuggested('C2');
     assertNotSuggested('name');
   }
 
   test_MethodDeclaration_returnType_afterComment3() async {
     // MethodDeclaration  ClassDeclaration  CompilationUnit
     addSource(
         '/testA.dart',
         '''
         int T1;
         F1() { }
         typedef D1();
         class C1 {C1(this.x) { } int x;}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         int T2;
         F2() { }
         typedef D2();
         class C2 {
           /// some dartdoc
           ^ zoo(z) { } String name; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
@@ skipping 181 matching lines @@
         '/testB.dart',
         '''
         lib B;
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
     addSource(
         '/testA.dart',
         '''
         library libA;
-        import "/testB.dart";
+        import "testB.dart";
         part "$testFile";
         class A { }
         var m;''');
     addTestSource('''
         part of libA;
         class B { factory B.bar(int x) => null; }
         main() {new ^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
@@ skipping 18 matching lines @@
         int T1;
         F1() { }
         class X {X.c(); X._d(); z() {}}''');
     addSource(
         '/testA.dart',
         '''
         part of libA;
         class B { }''');
     addTestSource('''
         library libA;
-        import "/testB.dart";
+        import "testB.dart";
         part "/testA.dart";
         class A { A({String boo: 'hoo'}) { } }
         main() {new ^}
         var m;''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('A');
     assertNotSuggested('Object');
     assertNotSuggested('X.c');
@@ skipping 17 matching lines @@
           X get f => new A();
           get _g => new A();}
         class B implements I {
           static const int scB = 12;
           var b; X _c;
           X get d => new A();get _e => new A();
           set s1(I x) {} set _s2(I x) {}
           m(X x) {} I _n(X x) {}}
         class X{}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class A extends B {
           static const String scA = 'foo';
           w() { }}
         main() {A.^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by StaticMemberContributor
     assertNotSuggested('scA');
     assertNotSuggested('scB');
@@ skipping 24 matching lines @@
         lib B;
         class I {X get f => new A();get _g => new A();}
         class A implements I {
           static const int sc = 12;
           @deprecated var b; X _c;
           X get d => new A();get _e => new A();
           set s1(I x) {} set _s2(I x) {}
           m(X x) {} I _n(X x) {}}
         class X{}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         main() {A a; a.^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('sc');
     assertSuggestField('b', null, isDeprecated: true);
     assertNotSuggested('_c');
     assertSuggestGetter('d', 'X');
     assertNotSuggested('_e');
     assertSuggestGetter('f', 'X');
@@ skipping 52 matching lines @@
   test_PrefixedIdentifier_library() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource(
         '/testB.dart',
         '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
     addTestSource('''
-        import "/testB.dart" as b;
+        import "testB.dart" as b;
         var T2;
         class A { }
         main() {b.^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LibraryMemberContributor
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('T1');
     assertNotSuggested('T2');
     assertNotSuggested('Object');
     assertNotSuggested('b');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_library_typesOnly() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
     addSource(
         '/testB.dart',
         '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
     addTestSource('''
-        import "/testB.dart" as b;
+        import "testB.dart" as b;
         var T2;
         class A { }
         foo(b.^ f) {}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LibraryMemberContributor
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('T1');
     assertNotSuggested('T2');
     assertNotSuggested('Object');
     assertNotSuggested('b');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_library_typesOnly2() async {
     // SimpleIdentifier  PrefixedIdentifier  TypeName
     addSource(
         '/testB.dart',
         '''
         lib B;
         var T1;
         class X { }
         class Y { }''');
     addTestSource('''
-        import "/testB.dart" as b;
+        import "testB.dart" as b;
         var T2;
         class A { }
         foo(b.^) {}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     // Suggested by LibraryMemberContributor
     assertNotSuggested('X');
     assertNotSuggested('Y');
     assertNotSuggested('T1');
     assertNotSuggested('T2');
     assertNotSuggested('Object');
     assertNotSuggested('b');
     assertNotSuggested('A');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_parameter() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource(
         '/testB.dart',
         '''
         lib B;
         class _W {M y; var _z;}
         class X extends _W {}
         class M{}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         foo(X x) {x.^}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertSuggestField('y', 'M');
     assertNotSuggested('_z');
     assertNotSuggested('==');
   }
 
   test_PrefixedIdentifier_prefix() async {
     // SimpleIdentifier  PrefixedIdentifier  ExpressionStatement
     addSource(
         '/testA.dart',
         '''
         class A {static int bar = 10;}
         _B() {}''');
     addTestSource('''
-        import "/testA.dart";
+        import "testA.dart";
         class X {foo(){A^.bar}}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('A');
     assertNotSuggested('X');
     assertNotSuggested('foo');
     assertNotSuggested('bar');
     assertNotSuggested('_B');
   }
@@ skipping 551 matching lines @@
 
   test_TypeArgumentList() async {
     // SimpleIdentifier  BinaryExpression  ExpressionStatement
     addSource(
         '/testA.dart',
         '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
     addTestSource('''
-        import "/testA.dart";'
+        import "testA.dart";'
         class C2 {int x;}
         F2() => 0;
         typedef int T2(int blat);
         class C<E> {}
         main() { C<^> c; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('Object');
     assertNotSuggested('C1');
     assertNotSuggested('T1');
     assertNotSuggested('C2');
     assertNotSuggested('T2');
     assertNotSuggested('F1');
     assertNotSuggested('F2');
   }
 
   test_TypeArgumentList2() async {
     // TypeName  TypeArgumentList  TypeName
     addSource(
         '/testA.dart',
         '''
         class C1 {int x;}
         F1() => 0;
         typedef String T1(int blat);''');
     addTestSource('''
-        import "/testA.dart";'
+        import "testA.dart";'
         class C2 {int x;}
         F2() => 0;
         typedef int T2(int blat);
         class C<E> {}
         main() { C<C^> c; }''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset - 1);
     expect(replacementLength, 1);
     assertNotSuggested('C1');
     assertNotSuggested('C2');
   }
 
   test_VariableDeclaration_name() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement  Block
     addSource(
         '/testB.dart',
         '''
         lib B;
         foo() { }
         class _B { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class Y {Y.c(); Y._d(); z() {}}
         main() {var ^}''');
     await computeSuggestions();
     assertNoSuggestions();
   }
 
   test_VariableDeclarationList_final() async {
     // VariableDeclarationList  VariableDeclarationStatement  Block
     addTestSource('main() {final ^} class C { }');
     await computeSuggestions();
     assertNotSuggested('Object');
     assertNotSuggested('C');
     assertNotSuggested('==');
   }
 
   test_VariableDeclarationStatement_RHS() async {
     // SimpleIdentifier  VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
     addSource(
         '/testB.dart',
         '''
         lib B;
         foo() { }
         class _B { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         class Y {Y.c(); Y._d(); z() {}}
         class C {bar(){var f; {var x;} var e = ^}}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('X');
     assertNotSuggested('_B');
     assertNotSuggested('Y');
     assertNotSuggested('C');
     assertNotSuggested('f');
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 
   test_VariableDeclarationStatement_RHS_missing_semicolon() async {
     // VariableDeclaration  VariableDeclarationList
     // VariableDeclarationStatement
     addSource(
         '/testB.dart',
         '''
         lib B;
         foo1() { }
         void bar1() { }
         class _B { }
         class X {X.c(); X._d(); z() {}}''');
     addTestSource('''
-        import "/testB.dart";
+        import "testB.dart";
         foo2() { }
         void bar2() { }
         class Y {Y.c(); Y._d(); z() {}}
         class C {bar(){var f; {var x;} var e = ^ var g}}''');
     await computeSuggestions();
     expect(replacementOffset, completionOffset);
     expect(replacementLength, 0);
     assertNotSuggested('X');
     assertNotSuggested('foo1');
     assertNotSuggested('bar1');
     assertNotSuggested('foo2');
     assertNotSuggested('bar2');
     assertNotSuggested('_B');
     assertNotSuggested('Y');
     assertNotSuggested('C');
     assertNotSuggested('f');
     assertNotSuggested('x');
     assertNotSuggested('e');
   }
 }