Add filtering to completion tests.

pkg/analysis_server/test/completion_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.completion.support;
 
 import 'dart:collection';
 
 import 'completion_test_support.dart';
 
@@ skipping 59 matching lines @@
 
     // space, char, eol are important
     CompletionTestCase.buildTests('testCommentSnippets011', '''
 class x implements M!1{}''', <String>["1+Map"]);
 
     // space, char, eol are important
     CompletionTestCase.buildTests('testCommentSnippets012', '''
 class x implements M!1\n{}''', <String>["1+Map"]);
 
     CompletionTestCase.buildTests('testCommentSnippets013', '''
-class x !2{!1}!3''',
-        <String>["1+num", "2-num", "3-num"]);
+class x !2{!1}!3''', <String>["1+num", "2-num", "3-num"], failingTests: '3');
 
     // trailing space is important
     CompletionTestCase.buildTests('testCommentSnippets014', '''
 typedef n!1 ;''', <String>["1+num"]);
 
     CompletionTestCase.buildTests('testCommentSnippets015', '''
 class D {f(){} g(){f!1(f!2);}}''', <String>["1+f", "2+f"]);
 
     CompletionTestCase.buildTests('testCommentSnippets016', '''
 class F {m() { m(); !1}}''', <String>["1+m"]);
@@ skipping 105 matching lines @@
     CompletionTestCase.buildTests('testCommentSnippets040', '''
 class List{add(){}}class Map{}class X{m(){List list; list.!1 Map map;}}''',
         <String>["1+add"]);
 
     CompletionTestCase.buildTests('testCommentSnippets041', '''
 class List{add(){}length(){}}class X{m(){List list; list.!1 zox();}}''',
         <String>["1+add"]);
 
     CompletionTestCase.buildTests('testCommentSnippets042', '''
 class DateTime{static const int WED=3;int get day;}fd(){DateTime d=new DateTime.now();d.!1WED!2;}''',
-        <String>["1+day", "2-WED"]);
+        <String>["1+day", "2-WED"],
+        failingTests: '2');
 
     CompletionTestCase.buildTests('testCommentSnippets043', '''
 class L{var k;void.!1}''', <String>["1-k"]);
 
     CompletionTestCase.buildTests('testCommentSnippets044', '''
 class List{}class XXX {XXX.fisk();}main() {main(); new !1}}''',
         <String>["1+List", "1+XXX.fisk"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets047', '''
@@ skipping 35 matching lines @@
             "1+xdr",
             "1+xa",
             "1+xdr.a",
             "1+xdr.b",
             "2-xa",
             "2-xdr",
             "2+xdr.a",
             "2-xdr.b",
             "3-b",
             "3+a"],
-        failingTests: '12');
+        failingTests: '123');
 
     // Type propagation.
     CompletionTestCase.buildTests('testCommentSnippets051', '''
 class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}}
 void r() {
   var v;
   if (v is String) {
     v.!1length;
     v.!2getKeys;
   }
@@ skipping 338 matching lines @@
             "1+FileMode._internal1",
             "1+FileMode._internal"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets078', '''
 class Map{static from()=>null;clear(){}}void main() { Map.!1 }''',
         <String>["1+from", "1-clear"]); // static method, instance method
 
     CompletionTestCase.buildTests('testCommentSnippets079', '''
 class Map{static from()=>null;clear(){}}void main() { Map s; s.!1 }''',
-        <String>["1-from", "1+clear"]); // static method, instance method
+        <String>["1-from", "1+clear"],
+        failingTests: '1'); // static method, instance method
 
     CompletionTestCase.buildTests('testCommentSnippets080', '''
 class RuntimeError{var message;}void main() { RuntimeError.!1 }''',
         <String>["1-message"]); // field
 
     CompletionTestCase.buildTests('testCommentSnippets081', '''
-class Foo {this.!1}''', <String>["1-Object"]);
+class Foo {this.!1}''', <String>["1-Object"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets082', '''
         class HttpRequest {}
         class HttpResponse {}
         main() {
           var v = (HttpRequest req, HttpResp!1)
         }''', <String>["1+HttpResponse"]);
 
     CompletionTestCase.buildTests('testCommentSnippets083', '''
-main() {(.!1)}''', <String>["1-toString"]);
+main() {(.!1)}''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets083a', '''
-main() { .!1 }''', <String>["1-toString"]);
+main() { .!1 }''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets083b', '''
 main() { null.!1 }''', <String>["1+toString"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets084', '''
 class List{}class Map{}typedef X = !1Lis!2t with !3Ma!4p;''',
         <String>["1+Map", "2+List", "2-Map", "3+List", "4+Map", "4-List"],
         failingTests: '1234');
 
     CompletionTestCase.buildTests('testCommentSnippets085', '''
 class List{}class Map{}class Z extends List with !1Ma!2p {}''',
         <String>["1+List", "1+Map", "2+Map", "2-List"],
         failingTests: '12');
 
     CompletionTestCase.buildTests('testCommentSnippets086', '''
-class Q{f(){xy() {!2};x!1y();}}''', <String>["1+xy", "2+f", "2-xy"]);
+class Q{f(){xy() {!2};x!1y();}}''',
+        <String>["1+xy", "2+f", "2-xy"],
+        failingTests: '2');
 
     CompletionTestCase.buildTests('testCommentSnippets087', '''
 class Map{}class Q extends Object with !1Map {}''',
         <String>["1+Map", "1-HashMap"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCommentSnippets088', '''
 class A {
   int f;
   B m(){}
@@ skipping 49 matching lines @@
             "4+fqi",
             "4+Q",
             "4+xya",
             "4-xyb",
             "4+xza",
             "5+fqe",
             "5+fqi",
             "5+Q",
             "5-xya",
             "5-xyb",
-            "5-xza"]);
+            "5-xza"],
+        failingTests: '123');
 
     CompletionTestCase.buildTests('testCommentSnippets090', '''
 class X { f() { var a = 'x'; a.!1 }}''',
         <String>["1+length"],
         failingTests: '1');
   }
 
   void buildCompletionTests() {
     CompletionTestCase.buildTests('testCompletion_alias_field', '''
 typedef int fnint(int k); fn!1int x;''', <String>["1+fnint"]);
 
     CompletionTestCase.buildTests('testCompletion_annotation_argumentList', '''
 class AAA {",
   const AAA({int aaa, int bbb});",
 }",
 ",
 @AAA(!1)
 main() {
 }''',
         <String>["1+AAA" /*":" + ProposalKind.ARGUMENT_LIST*/, "1+aaa", "1+bbb"],
         failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_annotation_topLevelVar', '''
 const fooConst = null;
 final fooNotConst = null;
 const bar = null;
 
 @foo!1
 main() {
-}''', <String>["1+fooConst", "1-fooNotConst", "1-bar"]);
+}''', <String>["1+fooConst", "1-fooNotConst", "1-bar"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_annotation_type', '''
 class AAA {
   const AAA({int a, int b});
   const AAA.nnn(int c, int d);
 }
 @AAA!1
 main() {
 }''',
         <String>[
@@ skipping 44 matching lines @@
 
 main(A p) {
   var v = p.as!1;
 }''', <String>["1+asVisible"]);
 
     CompletionTestCase.buildTests('testCompletion_as_incompleteStatement', '''
 class MyClass {}
 main(p) {
   var justSomeVar;
   var v = p as !1
-}''', <String>["1+MyClass", "1-justSomeVar"]);
+}''', <String>["1+MyClass", "1-justSomeVar"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_cascade', '''
 class A {
   aaa() {}
 }
 
 
 main(A a) {
   a..!1 aaa();
 }''', <String>["1+aaa", "1-main"]);
@@ skipping 154 matching lines @@
 class B {}
 /**
  * [!3] some text
  */
 class C {}''',
         <String>["1+double", "1-int", "2+int", "2+String", "3+int", "3+String"]);
 
     CompletionTestCase.buildTests('testCompletion_double_inFractionPart', '''
 main() {
   1.0!1
-}''', <String>["1-abs", "1-main"]);
+}''', <String>["1-abs", "1-main"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_enum', '''
 enum MyEnum {A, B, C}
 main() {
   MyEnum.!1;
 }''', <String>["1+values", "1+A", "1+B", "1+C"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_exactPrefix_hasHigherRelevance',
         '''
@@ skipping 215 matching lines @@
 main(A p) {
   var v1 = p.is!1;
   var v2 = p.is!2
 }''', <String>["1+isVisible", "2+isVisible"]);
 
     CompletionTestCase.buildTests('testCompletion_is_incompleteStatement1', '''
 class MyClass {}
 main(p) {
   var justSomeVar;
   var v = p is !1
-}''', <String>["1+MyClass", "1-justSomeVar"]);
+}''', <String>["1+MyClass", "1-justSomeVar"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_is_incompleteStatement2', '''
 class MyClass {}
 main(p) {
   var isVariable;
   var v = p is!1
 }''', <String>["1+is", "1-isVariable"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_keyword_in', '''
 class Foo { int input = 7; mth() { if (in!1) {}}}''', <String>["1+input"]);
 
     CompletionTestCase.buildTests(
         'testCompletion_keyword_syntheticIdentifier',
         '''
 main() {
   var caseVar;
   var otherVar;
   var v = case!1
 }''', <String>["1+caseVar", "1-otherVar"]);
 
     CompletionTestCase.buildTests('testCompletion_libraryIdentifier_atEOF', '''
-library int.!1''', <String>["1-parse", "1-bool"]);
+library int.!1''', <String>["1-parse", "1-bool"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_libraryIdentifier_notEOF', '''
-library int.!1''', <String>["1-parse", "1-bool"]);
+library int.!1''', <String>["1-parse", "1-bool"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_methodRef_asArg_incompatibleFunctionType',
         '''
 foo( f(int p) ) {}
 class Functions {
   static myFuncInt(int p) {}
   static myFuncDouble(double p) {}
 }
 bar(p) {}
 main(p) {
   foo( Functions.!1; );
 }''',
         <String>[
             "1+myFuncInt" /*":" + ProposalKind.METHOD_NAME*/,
-            "1-myFuncDouble" /*":" + ProposalKind.METHOD_NAME*/]);
+            "1-myFuncDouble" /*":" + ProposalKind.METHOD_NAME*/],
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_methodRef_asArg_notFunctionType',
         '''
 foo( f(int p) ) {}
 class Functions {
   static myFunc(int p) {}
 }
 bar(p) {}
 main(p) {
   foo( (int p) => Functions.!1; );
 }''',
         <String>[
             "1+myFunc" /*":" + ProposalKind.METHOD*/,
-            "1-myFunc" /*":" + ProposalKind.METHOD_NAME*/]);
+            "1-myFunc" /*":" + ProposalKind.METHOD_NAME*/],
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_methodRef_asArg_ofFunctionType',
         '''
 foo( f(int p) ) {}
 class Functions {
   static int myFunc(int p) {}
 }
 main(p) {
   foo(Functions.!1);
@@ skipping 141 matching lines @@
 class A {
   static int FIELD_A;
   static int methodA() {}
 }
 class B extends A {
   static int FIELD_B;
   static int methodB() {}
 }
 main() {
   B.!1;
-}''', <String>["1+FIELD_B", "1-FIELD_A", "1+methodB", "1-methodA"]);
+}''',
+        <String>["1+FIELD_B", "1-FIELD_A", "1+methodB", "1-methodA"],
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_propertyAccess_whenInstanceTarget',
         '''
 class A {
   static int FIELD;
   int fieldA;
 }
 class B {
   A a;
 }
 class C extends A {
   int fieldC;
 }
 main(B b, C c) {
   b.a.!1;
   c.!2;
-}''', <String>["1-FIELD", "1+fieldA", "2+fieldC", "2+fieldA"]);
+}''',
+        <String>["1-FIELD", "1+fieldA", "2+fieldC", "2+fieldA"],
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_return_withIdentifierPrefix',
         '''
 f() { var vvv = 42; return v!1 }''', <String>["1+vvv"]);
 
     CompletionTestCase.buildTests('testCompletion_return_withoutExpression', '''
 f() { var vvv = 42; return !1 }''', <String>["1+vvv"]);
 
     CompletionTestCase.buildTests('testCompletion_staticField1', '''
 class num{}class Sunflower {static final n!2um MAX_D = 300;nu!3m xc, yc;Sun!4flower() {x!Xc = y!Yc = MA!1 }}''',
         <String>["1+MAX_D", "X+xc", "Y+yc", "2+num", "3+num", "4+Sunflower"],
         failingTests: '234');
 
     CompletionTestCase.buildTests('testCompletion_super_superType', '''
 class A {
   var fa;
   ma() {}
 }
 class B extends A {
   var fb;
   mb() {}
   main() {
     super.!1
   }
-}''', <String>["1+fa", "1-fb", "1+ma", "1-mb"]);
+}''', <String>["1+fa", "1-fb", "1+ma", "1-mb"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_superConstructorInvocation_noNamePrefix',
         '''
 class A {
   A.fooA();
   A.fooB();
   A.bar();
 }
 class B extends A {
@@ skipping 11 matching lines @@
 class B extends A {
   B() : super.f!1
 }''', <String>["1+fooA", "1+fooB", "1-bar"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_this_bad_inConstructorInitializer',
         '''
 class A {
   var f;
   A() : f = this.!1;
-}''', <String>["1-toString"]);
+}''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_this_bad_inFieldDeclaration',
         '''
 class A {
   var f = this.!1;
-}''', <String>["1-toString"]);
+}''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests('testCompletion_this_bad_inStaticMethod', '''
 class A {
   static m() {
     this.!1;
   }
-}''', <String>["1-toString"]);
+}''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_this_bad_inTopLevelFunction',
         '''
 main() {
   this.!1;
-}''', <String>["1-toString"]);
+}''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_this_bad_inTopLevelVariableDeclaration',
         '''
-var v = this.!1;''', <String>["1-toString"]);
+var v = this.!1;''', <String>["1-toString"], failingTests: '1');
 
     CompletionTestCase.buildTests(
         'testCompletion_this_OK_inConstructorBody',
         '''
 class A {
   var f;
   m() {}
   A() {
     this.!1;
   }
@@ skipping 375 matching lines @@
             "7+Aclass",
             "7-Bclass",
             "8+Ctype",
             "9+abstract",
             "A+with",
             "B+Eclass",
             "B-Dclass",
             "B-Ctype",
             "C+Bclass",
             "C-Eclass"],
-        failingTests: '12359AB');
+        failingTests: '12345679ABC');
 
     // keywords
     CompletionTestCase.buildTests('test009', '''
 typedef !1dy!2namic TestFn1();
 typedef !3vo!4id TestFn2();
 typ!7edef !5n!6''',
         <String>[
             "1+void",
             "1+TestFn2",
             "2+dynamic",
@@ skipping 22 matching lines @@
             "6+List",
             "7-List",
             "8-List",
             "9-String",
             "A-String",
             "B+String",
             "C+List",
             "C-tezetst",
             "D+List",
             "D+test"],
-        failingTests: '345C');
+        failingTests: '12345C');
 
     // name generation with conflicts
     CompletionTestCase.buildTests(
         'test011',
         '''r2(var object, Object object1, Object !1);''',
         <String>["1+object2"],
         failingTests: '1');
 
     // reserved words
     CompletionTestCase.buildTests('test012', '''
@@ skipping 35 matching lines @@
             "2+x",
             "3+zs",
             "4+k",
             "5+Q",
             "5-a",
             "6+==",
             "7+x",
             "8+==",
             "9+==",
             "0+k"],
-        failingTests: '689');
+        failingTests: '5689');
 
     // keywords
     CompletionTestCase.buildTests('test014', '''
 class Q {
   bool x;
   List zs;
   int k;
   !Dvar a;
   !Evoid mth() {
     !1while (z) { !Gcontinue; };
@@ skipping 78 matching lines @@
 
     CompletionTestCase.buildTests(
         'test020',
         '''var x = null.!1''',
         <String>["1+toString"],
         failingTests: '1');
 
     CompletionTestCase.buildTests(
         'test021',
         '''var x = .!1''',
-        <String>["1-toString"]);
+        <String>["1-toString"],
+        failingTests: '1');
 
     CompletionTestCase.buildTests(
         'test022',
         '''var x = .!1;''',
-        <String>["1-toString"]);
+        <String>["1-toString"],
+        failingTests: '1');
 
     CompletionTestCase.buildTests('test023', '''
 class Map{getKeys(){}}
 class X {
   static x1(Map m) {
     m.!1getKeys;
   }
   x2(Map m) {
     m.!2getKeys;
   }
@@ skipping 49 matching lines @@
             "5+_m",
             "6+g",
             "7-g",
             "8-m",
             "9-_m",
             "A+_m",
             "B+m",
             "C+g",
             "D+_m",
             "E+m",
-            "F+g"]);
+            "F+g"],
+        failingTests: '789');
 
     CompletionTestCase.buildTests(
         'test026',
         '''var aBcD; var x=ab!1''',
         <String>["1+aBcD"]);
 
     CompletionTestCase.buildTests(
         'test027',
         '''m(){try{}catch(eeee,ssss){s!1}''',
         <String>["1+ssss"]);
 
     CompletionTestCase.buildTests(
         'test028',
         '''m(){var isX=3;if(is!1)''',
         <String>["1+isX"]);
 
     CompletionTestCase.buildTests(
         'test029',
         '''m(){[1].forEach((x)=>!1x);}''',
         <String>["1+x"]);
 
     CompletionTestCase.buildTests(
         'test030',
         '''n(){[1].forEach((x){!1});}''',
         <String>["1+x"]);
 
     CompletionTestCase.buildTests(
         'test031',
         '''class Caster {} m() {try {} on Cas!1ter catch (CastBlock) {!2}}''',
-        <String>["1+Caster", "1-CastBlock", "2+Caster", "2+CastBlock"]);
+        <String>["1+Caster", "1-CastBlock", "2+Caster", "2+CastBlock"],
+        failingTests: '1');
 
     CompletionTestCase.buildTests('test032', '''
 const ONE = 1;
 const ICHI = 10;
 const UKSI = 100;
 const EIN = 1000;
 m() {
   int x;
   switch (x) {
     case !3ICHI:
@@ skipping 69 matching lines @@
 main() {
   A1 a = new A1();
   a.field.!2
 }''', <String>["1+round", "2+round"], failingTests: '12');
 
     CompletionTestCase.buildTests('test037', '''
 class HttpServer{}
 class HttpClient{}
 main() {
   new HtS!1
-}''', <String>["1+HttpServer", "1-HttpClient"]);
+}''', <String>["1+HttpServer", "1-HttpClient"], failingTests: '1');
 
     CompletionTestCase.buildTests('test038', '''
 class X {
   x(){}
 }
 class Y {
   y(){}
 }
 class A<Z extends X> {
   Y ay;
@@ skipping 37 matching lines @@
         'test_classMembers_inGetter',
         '''class A { var fff; get z {ff!1}}''',
         <String>["1+fff"]);
 
     CompletionTestCase.buildTests(
         'testSingle',
         '''class A {int x; !2mth() {int y = this.x;}}class B{}''',
         <String>["2+B"]);
   }
 }