| // 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:async'; |
| import 'dart:collection'; |
| |
| import 'package:unittest/unittest.dart'; |
| |
| import 'completion_test_support.dart'; |
| import 'utils.dart'; |
| |
| main() { |
| initializeTestEnvironment(); |
| CompletionTestBuilder builder = new CompletionTestBuilder(); |
| builder.buildAll(); |
| } |
| |
| /** |
| * Assigning the name of a single test to this string causes just that test to |
| * be run. Assigning null to this string causes all tests to be run. |
| */ |
| const String SOLO_TEST = null; |
| |
| /** |
| * Type of functions used to create tests. |
| */ |
| typedef void _Tester(String spec, TestFunction body); |
| |
| /** |
| * A builder that builds the completion tests. |
| */ |
| class CompletionTestBuilder { |
| /** |
| * Number of tests that have been built that are expected to pass. |
| */ |
| int expectedPassCount = 0; |
| |
| /** |
| * Number of tests that have been built that are expected to fail. |
| */ |
| int expectedFailCount = 0; |
| |
| void buildAll() { |
| buildNumberedTests(); |
| buildCommentSnippetTests(); |
| buildCompletionTests(); |
| buildOtherTests(); |
| buildLibraryTests(); |
| int testCount = expectedPassCount + expectedFailCount; |
| print( |
| 'Total $testCount tests, of which $expectedFailCount are expected to fail.'); |
| } |
| |
| void buildCommentSnippetTests() { |
| buildTests( |
| 'testCommentSnippets001', |
| ''' |
| class X {static final num MAX = 0;num yc,xc;mth() {xc = yc = MA!1X;x!2c.abs();num f = M!3AX;}}''', |
| <String>["1+MAX", "2+xc", "3+MAX"]); |
| |
| buildTests( |
| 'testCommentSnippets002', |
| ''' |
| class Y {String x='hi';mth() {x.l!1ength;int n = 0;x!2.codeUnitAt(n!3);}}''', |
| <String>["1+length", "2+x", "3+n"]); |
| |
| buildTests( |
| 'testCommentSnippets004', |
| ''' |
| class A {!1int x; !2mth() {!3int y = this.!5x!6;}}class B{}''', |
| <String>["1+A", "2+B", "3+x", "3-y", "5+mth", "6+x"]); |
| |
| buildTests( |
| 'testCommentSnippets005', |
| ''' |
| class Date { static Date JUN, JUL;}class X { m() { return Da!1te.JU!2L; }}''', |
| <String>["1+Date", "2+JUN", "2+JUL"]); |
| |
| buildTests( |
| 'testCommentSnippets007', |
| ''' |
| class C {mth(Map x, !1) {}mtf(!2, Map x) {}m() {for (in!3t i=0; i<5; i++); A!4 x;}}class int{}class Arrays{}''', |
| <String>["1+bool", "2+bool", "3+int", "4+Arrays"]); |
| |
| buildTests( |
| 'testCommentSnippets008', |
| ''' |
| class Date{}final num M = Dat!1''', |
| <String>["1+Date"]); |
| |
| // space, char, eol are important |
| buildTests( |
| 'testCommentSnippets009', |
| ''' |
| class Maps{}class x extends!5 !2M!3 !4implements!6 !1\n{}''', |
| <String>[ |
| "1+Map", |
| "2+Maps", |
| "3+Maps", |
| "4-Maps", |
| "4+implements", |
| "5-Maps", |
| "6-Map", |
| "6+implements" |
| ], |
| failingTests: '46'); |
| |
| // space, char, eol are important |
| buildTests( |
| 'testCommentSnippets010', |
| ''' |
| class x implements !1{}''', |
| <String>["1+Map"]); |
| |
| // space, char, eol are important |
| buildTests( |
| 'testCommentSnippets011', |
| ''' |
| class x implements M!1{}''', |
| <String>["1+Map"]); |
| |
| // space, char, eol are important |
| buildTests( |
| 'testCommentSnippets012', |
| ''' |
| class x implements M!1\n{}''', |
| <String>["1+Map"]); |
| |
| buildTests( |
| 'testCommentSnippets013', |
| ''' |
| class x !2{!1}!3''', |
| <String>["1+num", "2-num", "3+num"]); |
| |
| // trailing space is important |
| buildTests( |
| 'testCommentSnippets014', |
| ''' |
| typedef n!1 ;''', |
| <String>["1+num"]); |
| |
| buildTests( |
| 'testCommentSnippets015', |
| ''' |
| class D {f(){} g(){f!1(f!2);}}''', |
| <String>["1+f", "2+f"]); |
| |
| buildTests( |
| 'testCommentSnippets016', |
| ''' |
| class F {m() { m(); !1}}''', |
| <String>["1+m"]); |
| |
| buildTests( |
| 'testCommentSnippets017', |
| ''' |
| class F {var x = !1false;}''', |
| <String>["1+true"]); |
| |
| buildTests( |
| 'testCommentSnippets018', |
| ''' |
| class Map{}class Arrays{}class C{ m(!1){} n(!2 x, q)''', |
| <String>["1+Map", "1-void", "1-null", "2+Arrays", "2-void", "2-null"]); |
| |
| buildTests( |
| 'testCommentSnippets019', |
| ''' |
| class A{m(){Object x;x.!1/**/clear()''', |
| <String>["1+toString"]); |
| |
| buildTests( |
| 'testCommentSnippets020', |
| ''' |
| classMap{}class tst {var newt;void newf(){}test() {var newz;new!1/**/;}}''', |
| <String>["1+newt", "1+newf", "1+newz", "1-Map"]); |
| |
| buildTests( |
| 'testCommentSnippets021', |
| ''' |
| class Map{}class tst {var newt;void newf(){}test() {var newz;new !1/**/;}}''', |
| <String>["1+Map", "1-newt"]); |
| |
| buildTests( |
| 'testCommentSnippets022', |
| ''' |
| class Map{}class F{m(){new !1;}}''', |
| <String>["1+Map"]); |
| |
| buildTests( |
| 'testCommentSnippets022a', |
| ''' |
| class Map{}class F{m(){new !1''', |
| <String>["1+Map"]); |
| |
| buildTests( |
| 'testCommentSnippets022b', |
| ''' |
| class Map{factory Map.qq(){return null;}}class F{m(){new Map.!1qq();}}''', |
| <String>["1+qq"]); |
| |
| buildTests( |
| 'testCommentSnippets023', |
| ''' |
| class X {X c; X(this.!1c!3) : super() {c.!2}}''', |
| <String>["1+c", "2+c", "3+c"]); |
| |
| buildTests( |
| 'testCommentSnippets024', |
| ''' |
| class q {m(Map q){var x;m(!1)}n(){var x;n(!2)}}''', |
| <String>["1+x", "2+x"]); |
| |
| buildTests( |
| 'testCommentSnippets025', |
| ''' |
| class q {num m() {var q; num x=!1 q!3 + !2/**/;}}''', |
| <String>["1+q", "2+q", "3+q"]); |
| |
| buildTests( |
| 'testCommentSnippets026', |
| ''' |
| class List{}class a implements !1{}''', |
| <String>["1+List"]); |
| |
| buildTests( |
| 'testCommentSnippets027', |
| ''' |
| class String{}class List{}class test <X extends !1String!2> {}''', |
| <String>["1+List", "2+String", "2-List"]); |
| |
| buildTests( |
| 'testCommentSnippets028', |
| ''' |
| class String{}class List{}class DateTime{}typedef T Y<T extends !1>(List input);''', |
| <String>["1+DateTime", "1+String"]); |
| |
| buildTests( |
| 'testCommentSnippets029', |
| ''' |
| interface A<X> default B<X extends !1List!2> {}''', |
| <String>["1+DateTime", "2+List"]); |
| |
| buildTests( |
| 'testCommentSnippets030', |
| ''' |
| class Bar<T extends Foo> {const Bar(!1T!2 k);T!3 m(T!4 a, T!5 b){}final T!6 f = null;}''', |
| <String>["1+T", "2+T", "3+T", "4+T", "5+T", "6+T"], |
| failingTests: '123456'); |
| |
| buildTests( |
| 'testCommentSnippets031', |
| ''' |
| class Bar<T extends Foo> {m(x){if (x is !1) return;if (x is!!!2)}}''', |
| <String>["1+Bar", "1+T", "2+T", "2+Bar"], |
| failingTests: '12'); |
| |
| buildTests( |
| 'testCommentSnippets032', |
| ''' |
| class Fit{}class Bar<T extends Fooa> {const !2F!1ara();}''', |
| <String>["1+Fit", "1+Fara", "1-Bar", "2+Fit"], |
| failingTests: '1'); |
| |
| // Type propagation |
| buildTests( |
| 'testCommentSnippets033', |
| ''' |
| class List{add(){}length(){}}t1() {var x;if (x is List) {x.!1add(3);}}''', |
| <String>["1+add", "1+length"]); |
| |
| // Type propagation |
| buildTests( |
| 'testCommentSnippets035', |
| ''' |
| class List{clear(){}length(){}}t3() {var x=new List(), y=x.!1length();x.!2clear();}''', |
| <String>["1+length", "2+clear"]); |
| |
| buildTests( |
| 'testCommentSnippets036', |
| ''' |
| class List{}t3() {var x=new List!1}''', |
| <String>["1+List"]); |
| |
| buildTests( |
| 'testCommentSnippets037', |
| ''' |
| class List{factory List.from(){}}t3() {var x=new List.!1}''', |
| <String>["1+from"]); |
| |
| buildTests( |
| 'testCommentSnippets038', |
| ''' |
| f(){int xa; String s = '\$x!1';}''', |
| <String>["1+xa"]); |
| |
| buildTests( |
| 'testCommentSnippets038a', |
| ''' |
| int xa; String s = '\$x!1\'''', |
| <String>["1+xa"]); |
| |
| buildTests( |
| 'testCommentSnippets039', |
| ''' |
| f(){int xa; String s = '\$!1';}''', |
| <String>["1+xa"]); |
| |
| buildTests( |
| 'testCommentSnippets039a', |
| ''' |
| int xa; String s = '\$!1\'''', |
| <String>["1+xa"]); |
| |
| buildTests( |
| 'testCommentSnippets040', |
| ''' |
| class List{add(){}}class Map{}class X{m(){List list; list.!1 Map map;}}''', |
| <String>["1+add"]); |
| |
| buildTests( |
| 'testCommentSnippets041', |
| ''' |
| class List{add(){}length(){}}class X{m(){List list; list.!1 zox();}}''', |
| <String>["1+add"]); |
| |
| 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"]); |
| |
| buildTests( |
| 'testCommentSnippets043', |
| ''' |
| class L{var k;void.!1}''', |
| <String>["1-k"]); |
| |
| buildTests( |
| 'testCommentSnippets044', |
| ''' |
| class List{}class XXX {XXX.fisk();}main() {main(); new !1}}''', |
| <String>["1+List", "1+XXX.fisk"]); |
| |
| buildTests( |
| 'testCommentSnippets047', |
| ''' |
| f(){int x;int y=!1;}''', |
| <String>["1+x"]); |
| |
| buildTests( |
| 'testCommentSnippets048', |
| ''' |
| import 'dart:convert' as json;f() {var x=new js!1}''', |
| <String>["1+json"]); |
| |
| buildTests( |
| 'testCommentSnippets049', |
| ''' |
| import 'dart:convert' as json; |
| import 'dart:convert' as jxx; |
| class JsonDecoderX{} |
| f1() {var x=new !2j!1s!3}''', |
| <String>[ |
| "1+json", |
| "1+jxx", |
| "2+json", |
| "2+jxx", |
| "2-JsonDecoder", |
| "3+json", |
| "3-jxx" |
| ]); |
| |
| buildTests( |
| 'testCommentSnippets050', |
| ''' |
| class xdr { |
| xdr(); |
| const xdr.a(a,b,c); |
| xdr.b(); |
| f() => 3; |
| } |
| class xa{} |
| k() { |
| new x!1dr().f(); |
| const x!2dr.!3a(1, 2, 3); |
| }''', |
| <String>[ |
| "1+xdr", |
| "1+xa", |
| "1+xdr.a", |
| "1+xdr.b", |
| "2+xa", // suggest default constructor |
| "2+xdr", // suggest normal constructor |
| "2+xdr.a", |
| "2+xdr.b", // suggest named constructor |
| "3+b", // suggest named constructor |
| "3+a" |
| ]); |
| |
| // Type propagation. |
| 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; |
| } |
| }''', |
| <String>["1+length", "2-getKeys"]); |
| |
| // Type propagation. |
| buildTests( |
| 'testCommentSnippets052', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| List<String> values = ['a','b','c']; |
| for (var v in values) { |
| v.!1toUpperCase; |
| v.!2getKeys; |
| } |
| }''', |
| <String>["1+toUpperCase", "2-getKeys"]); |
| |
| // Type propagation. |
| buildTests( |
| 'testCommentSnippets053', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| var v; |
| while (v is String) { |
| v.!1toUpperCase; |
| v.!2getKeys; |
| } |
| }''', |
| <String>["1+toUpperCase", "2-getKeys"]); |
| |
| buildTests( |
| 'testCommentSnippets054', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| var v; |
| for (; v is String; v.!1isEmpty) { |
| v.!2toUpperCase; |
| v.!3getKeys; |
| } |
| }''', |
| <String>["1+isEmpty", "2+toUpperCase", "3-getKeys"]); |
| |
| buildTests( |
| 'testCommentSnippets055', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r() { |
| String v; |
| if (v is Object) { |
| v.!1toUpperCase; |
| } |
| }''', |
| <String>["1+toUpperCase"]); |
| |
| // Type propagation. |
| buildTests( |
| 'testCommentSnippets056', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void f(var v) { |
| if (v is!! String) { |
| return; |
| } |
| v.!1toUpperCase; |
| }''', |
| <String>["1+toUpperCase"]); |
| |
| // Type propagation. |
| buildTests( |
| 'testCommentSnippets057', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void f(var v) { |
| if ((v as String).!2length == 0) { |
| v.!1toUpperCase; |
| } |
| }''', |
| <String>["1+toUpperCase", "2+length"]); |
| |
| buildTests( |
| 'testCommentSnippets058', |
| ''' |
| typedef vo!2id callback(int k); |
| void x(callback q){} |
| void r() { |
| callback v; |
| x(!1); |
| }''', |
| <String>["1+v", "2+void"], |
| failingTests: '2'); |
| |
| buildTests( |
| 'testCommentSnippets059', |
| ''' |
| f(){((int x) => x+4).!1call(1);}''', |
| <String>["1-call"]); |
| |
| buildTests( |
| 'testCommentSnippets060', |
| ''' |
| class Map{} |
| abstract class MM extends Map{factory MM() => new Map();} |
| class Z { |
| MM x; |
| f() { |
| x!1 |
| } |
| }''', |
| <String>["1+x", "1-x[]"]); |
| |
| buildTests( |
| 'testCommentSnippets061', |
| ''' |
| class A{m(){!1f(3);!2}}n(){!3f(3);!4}f(x)=>x*3;''', |
| <String>["1+f", "1+n", "2+f", "2+n", "3+f", "3+n", "4+f", "4+n"]); |
| |
| // Type propagation. |
| buildTests( |
| 'testCommentSnippets063', |
| ''' |
| class String{int length(){} String toUpperCase(){} bool isEmpty(){}}class Map{getKeys(){}} |
| void r(var v) { |
| v.!1toUpperCase; |
| assert(v is String); |
| v.!2toUpperCase; |
| }''', |
| <String>["1-toUpperCase", "2+toUpperCase"]); |
| |
| buildTests( |
| 'testCommentSnippets064', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.!9h()..!1a()..!2b().!7g(); |
| x.!8j..!3b()..!4c..!6c..!5a(); |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>[ |
| "1+a", |
| "2+b", |
| "1-g", |
| "2-h", |
| "3+b", |
| "4+c", |
| "5+a", |
| "6+c", |
| "7+g", |
| "8+j", |
| "9+h" |
| ]); |
| |
| buildTests( |
| 'testCommentSnippets065', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..!1; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>["1+a"]); |
| |
| buildTests( |
| 'testCommentSnippets066', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..!1; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>["1+b"]); |
| |
| buildTests( |
| 'testCommentSnippets067', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.h()..a()..c..!1; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>["1+b"]); |
| |
| buildTests( |
| 'testCommentSnippets068', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.j..b()..c..!1; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>["1+c"]); |
| |
| buildTests( |
| 'testCommentSnippets069', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.j..b()..!1; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>["1+c"]); |
| |
| buildTests( |
| 'testCommentSnippets070', |
| ''' |
| class Spline { |
| Line c; |
| Spline a() { |
| return this; |
| } |
| Line b() { |
| return null; |
| } |
| Spline f() { |
| Line x = new Line(); |
| x.j..!1; |
| } |
| } |
| class Line { |
| Spline j; |
| Line g() { |
| return this; |
| } |
| Spline h() { |
| return null; |
| } |
| }''', |
| <String>["1+b"]); |
| |
| buildTests( |
| 'testCommentSnippets072', |
| ''' |
| class X { |
| int _p; |
| set p(int x) => _p = x; |
| } |
| f() { |
| X x = new X(); |
| x.!1p = 3; |
| }''', |
| <String>["1+p"]); |
| |
| buildTests( |
| 'testCommentSnippets073', |
| ''' |
| class X { |
| m() { |
| JSON.stri!1; |
| X f = null; |
| } |
| } |
| class JSON { |
| static stringify() {} |
| }''', |
| <String>["1+stringify"]); |
| |
| buildTests( |
| 'testCommentSnippets074', |
| ''' |
| class X { |
| m() { |
| _x!1 |
| } |
| _x1(){} |
| }''', |
| <String>["1+_x1"]); |
| |
| buildTests( |
| 'testCommentSnippets075', |
| ''' |
| p(x)=>0;var E;f(q)=>!1p(!2E);''', |
| <String>["1+p", "2+E"]); |
| |
| buildTests( |
| 'testCommentSnippets076', |
| ''' |
| class Map<K,V>{}class List<E>{}class int{}main() {var m=new Map<Lis!1t<Map<int,in!2t>>,List<!3int>>();}''', |
| <String>["1+List", "2+int", "3+int"]); |
| |
| buildTests( |
| 'testCommentSnippets076a', |
| ''' |
| class Map<K,V>{}class List<E>{}class int{}main() {var m=new Map<Lis!1t<Map<int,in!2t>>,List<!3>>();}''', |
| <String>["1+List", "2+int", "3+int"]); |
| |
| buildTests( |
| 'testCommentSnippets077', |
| ''' |
| class FileMode { |
| static const READ = const FileMode._internal(0); |
| static const WRITE = const FileMode._internal(1); |
| static const APPEND = const FileMode._internal(2); |
| const FileMode._internal(int this._mode); |
| factory FileMode._internal1(int this._mode); |
| factory FileMode(_mode); |
| final int _mode; |
| } |
| class File { |
| factory File(String path) => null; |
| factory File.fromPath(Path path) => null; |
| } |
| f() => new Fil!1''', |
| <String>[ |
| "1+File", |
| "1+File.fromPath", |
| "1+FileMode", |
| "1+FileMode._internal1", |
| "1+FileMode._internal" |
| ]); |
| |
| buildTests( |
| 'testCommentSnippets078', |
| ''' |
| class Map{static from()=>null;clear(){}}void main() { Map.!1 }''', |
| <String>["1+from", "1-clear"]); // static method, instance method |
| |
| buildTests( |
| 'testCommentSnippets079', |
| ''' |
| class Map{static from()=>null;clear(){}}void main() { Map s; s.!1 }''', |
| <String>["1-from", "1+clear"]); // static method, instance method |
| |
| buildTests( |
| 'testCommentSnippets080', |
| ''' |
| class RuntimeError{var message;}void main() { RuntimeError.!1 }''', |
| <String>["1-message"]); // field |
| |
| buildTests( |
| 'testCommentSnippets081', |
| ''' |
| class Foo {this.!1}''', |
| <String>["1-Object"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCommentSnippets082', |
| ''' |
| class HttpRequest {} |
| class HttpResponse {} |
| main() { |
| var v = (HttpRequest req, HttpResp!1) |
| }''', |
| <String>["1+HttpResponse"]); |
| |
| buildTests( |
| 'testCommentSnippets083', |
| ''' |
| main() {(.!1)}''', |
| <String>["1-toString"]); |
| |
| buildTests( |
| 'testCommentSnippets083a', |
| ''' |
| main() { .!1 }''', |
| <String>["1-toString"]); |
| |
| buildTests( |
| 'testCommentSnippets083b', |
| ''' |
| main() { null.!1 }''', |
| <String>["1+toString"], |
| failingTests: '1'); |
| |
| 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'); |
| |
| buildTests( |
| 'testCommentSnippets085', |
| ''' |
| class List{}class Map{}class Z extends List with !1Ma!2p {}''', |
| <String>["1+List", "1+Map", "2+Map", "2-List"], |
| failingTests: '12'); |
| |
| buildTests( |
| 'testCommentSnippets086', |
| ''' |
| class Q{f(){xy() {!2};x!1y();}}''', |
| <String>["1+xy", "2+f", "2-xy"], |
| failingTests: '2'); |
| |
| buildTests( |
| 'testCommentSnippets087', |
| ''' |
| class Map{}class Q extends Object with !1Map {}''', |
| <String>["1+Map", "1-HashMap"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCommentSnippets088', |
| ''' |
| class A { |
| int f; |
| B m(){} |
| } |
| class B extends A { |
| num f; |
| A m(){} |
| } |
| class Z { |
| B q; |
| f() {q.!1} |
| }''', |
| <String>["1+f", "1+m"]); // f->num, m()->A |
| |
| buildTests( |
| 'testCommentSnippets089', |
| ''' |
| class Q { |
| fqe() { |
| xya() { |
| xyb() { |
| !1 |
| } |
| !3 xyb(); |
| }; |
| xza() { |
| !2 |
| } |
| xya(); |
| !4 xza(); |
| } |
| fqi() { |
| !5 |
| } |
| }''', |
| <String>[ |
| "1+fqe", |
| "1+fqi", |
| "1+Q", |
| "1-xya", |
| "1-xyb", |
| "1-xza", |
| "2+fqe", |
| "2+fqi", |
| "2+Q", |
| "2-xya", |
| "2-xyb", |
| "2-xza", |
| "3+fqe", |
| "3+fqi", |
| "3+Q", |
| "3-xya", |
| "3+xyb", |
| "3-xza", |
| "4+fqe", |
| "4+fqi", |
| "4+Q", |
| "4+xya", |
| "4-xyb", |
| "4+xza", |
| "5+fqe", |
| "5+fqi", |
| "5+Q", |
| "5-xya", |
| "5-xyb", |
| "5-xza" |
| ], |
| failingTests: '123'); |
| |
| buildTests( |
| 'testCommentSnippets090', |
| ''' |
| class X { f() { var a = 'x'; a.!1 }}''', |
| <String>["1+length"]); |
| } |
| |
| void buildCompletionTests() { |
| buildTests( |
| 'testCompletion_alias_field', |
| ''' |
| typedef int fnint(int k); fn!1int x;''', |
| <String>["1+fnint"]); |
| |
| 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'); |
| |
| buildTests( |
| 'testCompletion_annotation_topLevelVar', |
| ''' |
| const fooConst = null; |
| final fooNotConst = null; |
| const bar = null; |
| |
| @foo!1 |
| main() { |
| }''', |
| <String>["1+fooConst", "1-fooNotConst", "1-bar"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_annotation_type', |
| ''' |
| class AAA { |
| const AAA({int a, int b}); |
| const AAA.nnn(int c, int d); |
| } |
| @AAA!1 |
| main() { |
| }''', |
| <String>[ |
| "1+AAA" /*":" + ProposalKind.CONSTRUCTOR*/, |
| "1+AAA.nnn" /*":" + ProposalKind.CONSTRUCTOR*/ |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_annotation_type_inClass_withoutMember', |
| ''' |
| class AAA { |
| const AAA(); |
| } |
| |
| class C { |
| @A!1 |
| }''', |
| <String>["1+AAA" /*":" + ProposalKind.CONSTRUCTOR*/]); |
| |
| buildTests( |
| 'testCompletion_argument_typeName', |
| ''' |
| class Enum { |
| static Enum FOO = new Enum(); |
| } |
| f(Enum e) {} |
| main() { |
| f(En!1); |
| }''', |
| <String>["1+Enum"]); |
| |
| buildTests( |
| 'testCompletion_arguments_ignoreEmpty', |
| ''' |
| class A { |
| test() {} |
| } |
| main(A a) { |
| a.test(!1); |
| }''', |
| <String>["1-test"]); |
| |
| buildTests( |
| 'testCompletion_as_asIdentifierPrefix', |
| ''' |
| main(p) { |
| var asVisible; |
| var v = as!1; |
| }''', |
| <String>["1+asVisible"]); |
| |
| buildTests( |
| 'testCompletion_as_asPrefixedIdentifierStart', |
| ''' |
| class A { |
| var asVisible; |
| } |
| |
| main(A p) { |
| var v = p.as!1; |
| }''', |
| <String>["1+asVisible"]); |
| |
| buildTests( |
| 'testCompletion_as_incompleteStatement', |
| ''' |
| class MyClass {} |
| main(p) { |
| var justSomeVar; |
| var v = p as !1 |
| }''', |
| <String>["1+MyClass", "1-justSomeVar"]); |
| |
| buildTests( |
| 'testCompletion_cascade', |
| ''' |
| class A { |
| aaa() {} |
| } |
| |
| |
| main(A a) { |
| a..!1 aaa(); |
| }''', |
| <String>["1+aaa", "1-main"]); |
| |
| buildTests( |
| 'testCompletion_combinator_afterComma', |
| ''' |
| "import 'dart:math' show cos, !1;''', |
| <String>["1+PI", "1+sin", "1+Random", "1-String"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_combinator_ended', |
| ''' |
| import 'dart:math' show !1;"''', |
| <String>["1+PI", "1+sin", "1+Random", "1-String"]); |
| |
| buildTests( |
| 'testCompletion_combinator_export', |
| ''' |
| export 'dart:math' show !1;"''', |
| <String>["1+PI", "1+sin", "1+Random", "1-String"]); |
| |
| buildTests( |
| 'testCompletion_combinator_hide', |
| ''' |
| import 'dart:math' hide !1;"''', |
| <String>["1+PI", "1+sin", "1+Random", "1-String"]); |
| |
| buildTests( |
| 'testCompletion_combinator_notEnded', |
| ''' |
| import 'dart:math' show !1"''', |
| <String>["1+PI", "1+sin", "1+Random", "1-String"]); |
| |
| buildTests( |
| 'testCompletion_combinator_usePrefix', |
| ''' |
| import 'dart:math' show s!1"''', |
| <String>["1+sin", "1+sqrt", "1-cos", "1-String"]); |
| |
| buildTests( |
| 'testCompletion_constructor_field', |
| ''' |
| class X { X(this.field); int f!1ield;}''', |
| <String>["1+field"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_constructorArguments_showOnlyCurrent', |
| ''' |
| class A { |
| A.first(int p); |
| A.second(double p); |
| } |
| main() { |
| new A.first(!1); |
| }''', |
| <String>["1+A.first", "1-A.second"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_constructorArguments_whenPrefixedType', |
| ''' |
| import 'dart:math' as m; |
| main() { |
| new m.Random(!1); |
| }''', |
| <String>["1+Random:ARGUMENT_LIST"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_dartDoc_reference_forClass', |
| ''' |
| /** |
| * [int!1] |
| * [method!2] |
| */ |
| class AAA { |
| methodA() {} |
| }''', |
| <String>["1+int", "1-method", "2+methodA", "2-int"]); |
| |
| buildTests( |
| 'testCompletion_dartDoc_reference_forConstructor', |
| ''' |
| class A { |
| /** |
| * [aa!1] |
| * [int!2] |
| * [method!3] |
| */ |
| A.named(aaa, bbb) {} |
| methodA() {} |
| }''', |
| <String>["1+aaa", "1-bbb", "2+int", "2-double", "3+methodA"]); |
| |
| buildTests( |
| 'testCompletion_dartDoc_reference_forFunction', |
| ''' |
| /** |
| * [aa!1] |
| * [int!2] |
| * [function!3] |
| */ |
| functionA(aaa, bbb) {} |
| functionB() {}''', |
| <String>[ |
| "1+aaa", |
| "1-bbb", |
| "2+int", |
| "2-double", |
| "3+functionA", |
| "3+functionB", |
| "3-int" |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_dartDoc_reference_forFunctionTypeAlias', |
| ''' |
| /** |
| * [aa!1] |
| * [int!2] |
| * [Function!3] |
| */ |
| typedef FunctionA(aaa, bbb) {} |
| typedef FunctionB() {}''', |
| <String>[ |
| "1+aaa", |
| "1-bbb", |
| "2+int", |
| "2-double", |
| "3+FunctionA", |
| "3+FunctionB", |
| "3-int" |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_dartDoc_reference_forMethod', |
| ''' |
| class A { |
| /** |
| * [aa!1] |
| * [int!2] |
| * [method!3] |
| */ |
| methodA(aaa, bbb) {} |
| methodB() {} |
| }''', |
| <String>[ |
| "1+aaa", |
| "1-bbb", |
| "2+int", |
| "2-double", |
| "3+methodA", |
| "3+methodB", |
| "3-int" |
| ]); |
| |
| buildTests( |
| 'testCompletion_dartDoc_reference_incomplete', |
| ''' |
| /** |
| * [doubl!1 some text |
| * other text |
| */ |
| class A {} |
| /** |
| * [!2 some text |
| * other text |
| */ |
| class B {} |
| /** |
| * [!3] some text |
| */ |
| class C {}''', |
| <String>[ |
| "1+double", |
| "1-int", |
| "2+int", |
| "2+String", |
| "3+int", |
| "3+String" |
| ]); |
| |
| buildTests( |
| 'testCompletion_double_inFractionPart', |
| ''' |
| main() { |
| 1.0!1 |
| }''', |
| <String>["1-abs", "1-main"]); |
| |
| buildTests( |
| 'testCompletion_enum', |
| ''' |
| enum MyEnum {A, B, C} |
| main() { |
| MyEnum.!1; |
| }''', |
| <String>["1+values", "1+A", "1+B", "1+C"]); |
| |
| buildTests( |
| 'testCompletion_exactPrefix_hasHigherRelevance', |
| ''' |
| var STR; |
| main(p) { |
| var str; |
| str!1; |
| STR!2; |
| Str!3; |
| }''', |
| <String>[ |
| "1+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/, |
| "1+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/, |
| "2+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/, |
| "2+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/, |
| "3+String" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 1)*/, |
| "3+STR" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/, |
| "3+str" /*",rel=" + (CompletionProposal.RELEVANCE_DEFAULT + 0)*/ |
| ]); |
| |
| buildTests( |
| 'testCompletion_export_dart', |
| ''' |
| import 'dart:math |
| import 'dart:_chrome |
| import 'dart:_collection.dev |
| export 'dart:!1''', |
| <String>[ |
| "1+dart:core", |
| "1+dart:math", |
| "1-dart:_chrome", |
| "1-dart:_collection.dev" |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_export_noStringLiteral_noSemicolon', |
| ''' |
| import !1 |
| |
| class A {}''', |
| <String>["1+'dart:!';", "1+'package:!';"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_forStmt_vars', |
| ''' |
| class int{}class Foo { mth() { for (in!1t i = 0; i!2 < 5; i!3++); }}''', |
| <String>["1+int", "2+i", "3+i"]); |
| |
| buildTests( |
| 'testCompletion_function', |
| ''' |
| class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1) => a.compareTo(b)); }}''', |
| <String>["1+String"]); |
| |
| buildTests( |
| 'testCompletion_function_partial', |
| ''' |
| class Foo { int boo = 7; mth() { PNGS.sort((String a, Str!1)); }}''', |
| <String>["1+String"]); |
| |
| buildTests( |
| 'testCompletion_functionTypeParameter_namedArgument', |
| ''' |
| typedef FFF(a, b, {x1, x2, y}); |
| main(FFF fff) { |
| fff(1, 2, !1)!2; |
| }''', |
| <String>["1+x1", "2-x2"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_ifStmt_field1', |
| ''' |
| class Foo { int myField = 7; mth() { if (!1) {}}}''', |
| <String>["1+myField"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_field1a', |
| ''' |
| class Foo { int myField = 7; mth() { if (!1) }}''', |
| <String>["1+myField"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_field2', |
| ''' |
| class Foo { int myField = 7; mth() { if (m!1) {}}}''', |
| <String>["1+myField"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_field2a', |
| ''' |
| class Foo { int myField = 7; mth() { if (m!1) }}''', |
| <String>["1+myField"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_field2b', |
| ''' |
| class Foo { myField = 7; mth() { if (m!1) {}}}''', |
| <String>["1+myField"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_localVar', |
| ''' |
| class Foo { mth() { int value = 7; if (v!1) {}}}''', |
| <String>["1+value"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_localVara', |
| ''' |
| class Foo { mth() { value = 7; if (v!1) {}}}''', |
| <String>["1-value"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_topLevelVar', |
| ''' |
| int topValue = 7; class Foo { mth() { if (t!1) {}}}''', |
| <String>["1+topValue"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_topLevelVara', |
| ''' |
| topValue = 7; class Foo { mth() { if (t!1) {}}}''', |
| <String>["1+topValue"]); |
| |
| buildTests( |
| 'testCompletion_ifStmt_unionType_nonStrict', |
| ''' |
| class A { a() => null; x() => null} |
| class B { a() => null; y() => null} |
| void main() { |
| var x; |
| var c; |
| if(c) { |
| x = new A(); |
| } else { |
| x = new B(); |
| } |
| x.!1; |
| }''', |
| <String>["1+a", "1+x", "1+y"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_ifStmt_unionType_strict', |
| ''' |
| class A { a() => null; x() => null} |
| class B { a() => null; y() => null} |
| void main() { |
| var x; |
| var c; |
| if(c) { |
| x = new A(); |
| } else { |
| x = new B(); |
| } |
| x.!1; |
| }''', |
| <String>["1+a", "1-x", "1-y"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_import', |
| ''' |
| import '!1';''', |
| <String>["1+dart:!", "1+package:!"]); |
| |
| buildTests( |
| 'testCompletion_import_dart', |
| ''' |
| import 'dart:math |
| import 'dart:_chrome |
| import 'dart:_collection.dev |
| import 'dart:!1''', |
| <String>[ |
| "1+dart:core", |
| "1+dart:math", |
| "1-dart:_chrome", |
| "1-dart:_collection.dev" |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_import_hasStringLiteral_noSemicolon', |
| ''' |
| import '!1' |
| |
| class A {}''', |
| <String>["1+dart:!", "1+package:!"]); |
| |
| buildTests( |
| 'testCompletion_import_noSpace', |
| ''' |
| import!1''', |
| <String>["1+ 'dart:!';", "1+ 'package:!';"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_import_noStringLiteral', |
| ''' |
| import !1;''', |
| <String>["1+'dart:!'", "1+'package:!'"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_import_noStringLiteral_noSemicolon', |
| ''' |
| import !1 |
| |
| class A {}''', |
| <String>["1+'dart:!';", "1+'package:!';"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_incompleteClassMember', |
| ''' |
| class A { |
| Str!1 |
| final f = null; |
| }''', |
| <String>["1+String", "1-bool"]); |
| |
| buildTests( |
| 'testCompletion_incompleteClosure_parameterType', |
| ''' |
| f1(cb(String s)) {} |
| f2(String s) {} |
| main() { |
| f1((Str!1)); |
| f2((Str!2)); |
| }''', |
| <String>["1+String", "1-bool", "2+String", "2-bool"]); |
| |
| buildTests( |
| 'testCompletion_inPeriodPeriod', |
| ''' |
| main(String str) { |
| 1 < str.!1.length; |
| 1 + str.!2.length; |
| 1 + 2 * str.!3.length; |
| }''', |
| <String>["1+codeUnits", "2+codeUnits", "3+codeUnits"], |
| failingTests: '123'); |
| |
| // no checks, but no exceptions |
| buildTests( |
| 'testCompletion_instanceCreation_unresolved', |
| ''' |
| class A { |
| } |
| main() { |
| new NoSuchClass(!1); |
| new A.noSuchConstructor(!2); |
| }''', |
| <String>["1+int", "2+int"]); |
| |
| buildTests( |
| 'testCompletion_import_lib', |
| ''' |
| import '!1''', |
| <String>["1+my_lib.dart"], |
| extraFiles: <String, String>{"/my_lib.dart": ""}, |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_is', |
| ''' |
| class MyClass {} |
| main(p) { |
| var isVariable; |
| if (p is MyCla!1) {} |
| var v1 = p is MyCla!2; |
| var v2 = p is !3; |
| var v2 = p is!4; |
| }''', |
| <String>[ |
| "1+MyClass", |
| "2+MyClass", |
| "3+MyClass", |
| "3-v1", |
| "4+is", |
| "4-isVariable" |
| ]); |
| |
| buildTests( |
| 'testCompletion_is_asIdentifierStart', |
| ''' |
| main(p) { |
| var isVisible; |
| var v1 = is!1; |
| var v2 = is!2 |
| }''', |
| <String>["1+isVisible", "2+isVisible"]); |
| |
| buildTests( |
| 'testCompletion_is_asPrefixedIdentifierStart', |
| ''' |
| class A { |
| var isVisible; |
| } |
| |
| main(A p) { |
| var v1 = p.is!1; |
| var v2 = p.is!2 |
| }''', |
| <String>["1+isVisible", "2+isVisible"]); |
| |
| buildTests( |
| 'testCompletion_is_incompleteStatement1', |
| ''' |
| class MyClass {} |
| main(p) { |
| var justSomeVar; |
| var v = p is !1 |
| }''', |
| <String>["1+MyClass", "1-justSomeVar"]); |
| |
| buildTests( |
| 'testCompletion_is_incompleteStatement2', |
| ''' |
| class MyClass {} |
| main(p) { |
| var isVariable; |
| var v = p is!1 |
| }''', |
| <String>["1+is", "1-isVariable"]); |
| |
| buildTests( |
| 'testCompletion_keyword_in', |
| ''' |
| class Foo { int input = 7; mth() { if (in!1) {}}}''', |
| <String>["1+input"]); |
| |
| buildTests( |
| 'testCompletion_keyword_syntheticIdentifier', |
| ''' |
| main() { |
| var caseVar; |
| var otherVar; |
| var v = case!1 |
| }''', |
| <String>["1+caseVar", "1-otherVar"]); |
| |
| buildTests( |
| 'testCompletion_libraryIdentifier_atEOF', |
| ''' |
| library int.!1''', |
| <String>["1-parse", "1-bool"]); |
| |
| buildTests( |
| 'testCompletion_libraryIdentifier_notEOF', |
| ''' |
| library int.!1''', |
| <String>["1-parse", "1-bool"]); |
| |
| 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*/ |
| ], |
| failingTests: '1'); |
| |
| 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*/ |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_methodRef_asArg_ofFunctionType', |
| ''' |
| foo( f(int p) ) {} |
| class Functions { |
| static int myFunc(int p) {} |
| } |
| main(p) { |
| foo(Functions.!1); |
| }''', |
| <String>[ |
| "1+myFunc" /*":" + ProposalKind.METHOD*/, |
| "1+myFunc" /*":" + ProposalKind.METHOD_NAME*/ |
| ]); |
| |
| buildTests( |
| 'testCompletion_namedArgument_alreadyUsed', |
| ''' |
| func({foo}) {} main() { func(foo: 0, fo!1); }''', |
| <String>["1-foo"]); |
| |
| buildTests( |
| 'testCompletion_namedArgument_constructor', |
| ''' |
| class A {A({foo, bar}) {}} main() { new A(fo!1); }''', |
| <String>["1+foo", "1-bar"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_namedArgument_empty', |
| ''' |
| func({foo, bar}) {} main() { func(!1); }''', |
| <String>[ |
| "1+foo" /*":" + ProposalKind.NAMED_ARGUMENT*/, |
| "1-foo" /*":" + ProposalKind.OPTIONAL_ARGUMENT*/ |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_namedArgument_function', |
| ''' |
| func({foo, bar}) {} main() { func(fo!1); }''', |
| <String>["1+foo", "1-bar"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_namedArgument_notNamed', |
| ''' |
| func([foo]) {} main() { func(fo!1); }''', |
| <String>["1-foo"]); |
| |
| buildTests( |
| 'testCompletion_namedArgument_unresolvedFunction', |
| ''' |
| main() { func(fo!1); }''', |
| <String>["1-foo"]); |
| |
| buildTests( |
| 'testCompletion_newMemberType1', |
| ''' |
| class Collection{}class List extends Collection{}class Foo { !1 }''', |
| <String>["1+Collection", "1+List"]); |
| |
| buildTests( |
| 'testCompletion_newMemberType2', |
| ''' |
| class Collection{}class List extends Collection{}class Foo {!1}''', |
| <String>["1+Collection", "1+List"]); |
| |
| buildTests( |
| 'testCompletion_newMemberType3', |
| ''' |
| class Collection{}class List extends Collection{}class Foo {L!1}''', |
| <String>["1-Collection", "1+List"]); |
| |
| buildTests( |
| 'testCompletion_newMemberType4', |
| ''' |
| class Collection{}class List extends Collection{}class Foo {C!1}''', |
| <String>["1+Collection", "1-List"]); |
| |
| buildTests( |
| 'testCompletion_positionalArgument_constructor', |
| ''' |
| class A { |
| A([foo, bar]); |
| } |
| main() { |
| new A(!1); |
| new A(0, !2); |
| }''', |
| <String>[ |
| "1+foo" /*":" + ProposalKind.OPTIONAL_ARGUMENT*/, |
| "1-bar", |
| "2-foo", |
| "2+bar" /*":" |
| + ProposalKind.OPTIONAL_ARGUMENT*/ |
| ], |
| failingTests: '12'); |
| |
| buildTests( |
| 'testCompletion_positionalArgument_function', |
| ''' |
| func([foo, bar]) {} |
| main() { |
| func(!1); |
| func(0, !2); |
| }''', |
| <String>[ |
| "1+foo" /*":" + ProposalKind.OPTIONAL_ARGUMENT*/, |
| "1-bar", |
| "2-foo", |
| "2+bar" /*":" |
| + ProposalKind.OPTIONAL_ARGUMENT*/ |
| ], |
| failingTests: '12'); |
| |
| buildTests( |
| 'testCompletion_preferStaticType', |
| ''' |
| class A { |
| foo() {} |
| } |
| class B extends A { |
| bar() {} |
| } |
| main() { |
| A v = new B(); |
| v.!1 |
| }''', |
| <String>[ |
| "1+foo", |
| "1-bar,potential=false,declaringType=B", |
| "1+bar,potential=true,declaringType=B" |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_privateElement_sameLibrary_constructor', |
| ''' |
| class A { |
| A._c(); |
| A.c(); |
| } |
| main() { |
| new A.!1 |
| }''', |
| <String>["1+_c", "1+c"]); |
| |
| buildTests( |
| 'testCompletion_privateElement_sameLibrary_member', |
| ''' |
| class A { |
| _m() {} |
| m() {} |
| } |
| main(A a) { |
| a.!1 |
| }''', |
| <String>["1+_m", "1+m"]); |
| |
| buildTests( |
| 'testCompletion_propertyAccess_whenClassTarget', |
| ''' |
| class A { |
| static int FIELD; |
| int field; |
| } |
| main() { |
| A.!1 |
| }''', |
| <String>["1+FIELD", "1-field"]); |
| |
| buildTests( |
| 'testCompletion_propertyAccess_whenClassTarget_excludeSuper', |
| ''' |
| 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"], |
| failingTests: '1'); |
| |
| 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"]); |
| |
| buildTests( |
| 'testCompletion_return_withIdentifierPrefix', |
| ''' |
| f() { var vvv = 42; return v!1 }''', |
| <String>["1+vvv"]); |
| |
| buildTests( |
| 'testCompletion_return_withoutExpression', |
| ''' |
| f() { var vvv = 42; return !1 }''', |
| <String>["1+vvv"]); |
| |
| 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"]); |
| |
| 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"]); |
| |
| buildTests( |
| 'testCompletion_superConstructorInvocation_noNamePrefix', |
| ''' |
| class A { |
| A.fooA(); |
| A.fooB(); |
| A.bar(); |
| } |
| class B extends A { |
| B() : super.!1 |
| }''', |
| <String>["1+fooA", "1+fooB", "1+bar"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_superConstructorInvocation_withNamePrefix', |
| ''' |
| class A { |
| A.fooA(); |
| A.fooB(); |
| A.bar(); |
| } |
| class B extends A { |
| B() : super.f!1 |
| }''', |
| <String>["1+fooA", "1+fooB", "1-bar"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_this_bad_inConstructorInitializer', |
| ''' |
| class A { |
| var f; |
| A() : f = this.!1; |
| }''', |
| <String>["1-toString"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_this_bad_inFieldDeclaration', |
| ''' |
| class A { |
| var f = this.!1; |
| }''', |
| <String>["1-toString"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_this_bad_inStaticMethod', |
| ''' |
| class A { |
| static m() { |
| this.!1; |
| } |
| }''', |
| <String>["1-toString"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_this_bad_inTopLevelFunction', |
| ''' |
| main() { |
| this.!1; |
| }''', |
| <String>["1-toString"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_this_bad_inTopLevelVariableDeclaration', |
| ''' |
| var v = this.!1;''', |
| <String>["1-toString"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'testCompletion_this_OK_inConstructorBody', |
| ''' |
| class A { |
| var f; |
| m() {} |
| A() { |
| this.!1; |
| } |
| }''', |
| <String>["1+f", "1+m"]); |
| |
| buildTests( |
| 'testCompletion_this_OK_localAndSuper', |
| ''' |
| class A { |
| var fa; |
| ma() {} |
| } |
| class B extends A { |
| var fb; |
| mb() {} |
| main() { |
| this.!1 |
| } |
| }''', |
| <String>["1+fa", "1+fb", "1+ma", "1+mb"]); |
| |
| buildTests( |
| 'testCompletion_topLevelField_init2', |
| ''' |
| class DateTime{static var JUN;}final num M = Dat!1eTime.JUN;''', |
| <String>["1+DateTime", "1-void"]); |
| |
| buildTests( |
| 'testCompletion_while', |
| ''' |
| class Foo { int boo = 7; mth() { while (b!1) {} }}''', |
| <String>["1+boo"]); |
| } |
| |
| void buildLibraryTests() { |
| Map<String, String> sources = new HashMap<String, String>(); |
| |
| buildTests( |
| 'test_export_ignoreIfThisLibraryExports', |
| ''' |
| export 'dart:math'; |
| libFunction() {}; |
| main() { |
| !1 |
| }''', |
| <String>["1-cos", "1+libFunction"]); |
| |
| sources.clear(); |
| sources["/lib.dart"] = ''' |
| library lib; |
| export 'dart:math' hide sin; |
| libFunction() {};'''; |
| buildTests( |
| 'test_export_showIfImportLibraryWithExport', |
| ''' |
| import 'lib.dart' as p; |
| main() { |
| p.!1 |
| }''', |
| <String>["1+cos", "1-sin", "1+libFunction"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| buildTests( |
| 'test_importPrefix_hideCombinator', |
| ''' |
| import 'dart:math' as math hide PI; |
| main() { |
| math.!1 |
| }''', |
| <String>["1-PI", "1+LN10"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'test_importPrefix_showCombinator', |
| ''' |
| import 'dart:math' as math show PI; |
| main() { |
| math.!1 |
| }''', |
| <String>["1+PI", "1-LN10"], |
| failingTests: '1'); |
| |
| sources.clear(); |
| sources["/lib.dart"] = ''' |
| library lib |
| class _A |
| foo() {} |
| |
| class A extends _A { |
| }'''; |
| buildTests( |
| 'test_memberOfPrivateClass_otherLibrary', |
| ''' |
| import 'lib.dart'; |
| main(A a) { |
| a.!1 |
| }''', |
| <String>["1+foo"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| sources.clear(); |
| sources["/lib.dart"] = ''' |
| library lib; |
| class A { |
| A.c(); |
| A._c(); |
| }'''; |
| buildTests( |
| 'test_noPrivateElement_otherLibrary_constructor', |
| ''' |
| import 'lib.dart'; |
| main() { |
| new A.!1 |
| }''', |
| <String>["1-_c", "1+c"], |
| failingTests: '1'); |
| |
| sources.clear(); |
| sources["/lib.dart"] = ''' |
| library lib; |
| class A { |
| var f; |
| var _f; |
| }'''; |
| buildTests( |
| 'test_noPrivateElement_otherLibrary_member', |
| ''' |
| import 'lib.dart'; |
| main(A a) { |
| a.!1 |
| }''', |
| <String>["1-_f", "1+f"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| sources.clear(); |
| sources["/firth.dart"] = ''' |
| library firth; |
| class SerializationException { |
| const SerializationException(); |
| }'''; |
| buildTests( |
| 'testLibrary001', |
| ''' |
| import 'firth.dart'; |
| main() { |
| throw new Seria!1lizationException();}''', |
| <String>["1+SerializationException"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| // Type propagation. |
| // TODO Include corelib analysis (this works in the editor) |
| buildTests( |
| 'testLibrary002', |
| '''t2() {var q=[0],z=q.!1length;q.!2clear();}''', |
| <String>["1+length", "1+isEmpty", "2+clear"], |
| failingTests: '1'); |
| |
| // TODO Include corelib analysis |
| buildTests('testLibrary003', '''class X{var q; f() {q.!1a!2}}''', |
| <String>["1+end", "2+abs", "2-end"], |
| failingTests: '12'); |
| |
| // TODO Include corelib analysis |
| // Resolving dart:html takes between 2.5s and 30s; json, about 0.12s |
| buildTests( |
| 'testLibrary004', |
| ''' |
| library foo; |
| import 'dart:convert' as json; |
| class JsonDecoderX{} |
| f1() {var x=new json.!1} |
| f2() {var x=new json.JsonDe!2} |
| f3() {var x=new json.JsonDecoder!3}''', |
| <String>[ |
| "1+JsonDecoder", |
| "1-JsonDecoderX", |
| "2+JsonDecoder", |
| "2-JsonDecoderX", |
| "3+JsonDecoder", |
| "3-JsonDecoderX" |
| ]); |
| |
| // TODO Enable after type propagation is implemented. Not yet. |
| // TODO Include corelib analysis |
| buildTests('testLibrary005', |
| '''var PHI;main(){PHI=5.3;PHI.abs().!1 Object x;}''', <String>["1+abs"], |
| failingTests: '1'); |
| |
| // Exercise import and export handling. |
| // Libraries are defined in partial order of increasing dependency. |
| sources.clear(); |
| sources["/exp2a.dart"] = ''' |
| library exp2a; |
| e2a() {}'''; |
| sources["/exp1b.dart"] = ''' |
| library exp1b;", |
| e1b() {}'''; |
| sources["/exp1a.dart"] = ''' |
| library exp1a;", |
| export 'exp1b.dart';", |
| e1a() {}'''; |
| sources["/imp1.dart"] = ''' |
| library imp1; |
| export 'exp1a.dart'; |
| i1() {}'''; |
| sources["/imp2.dart"] = ''' |
| library imp2; |
| export 'exp2a.dart'; |
| i2() {}'''; |
| buildTests( |
| 'testLibrary006', |
| ''' |
| import 'imp1.dart'; |
| import 'imp2.dart'; |
| main() {!1 |
| i1(); |
| i2(); |
| e1a(); |
| e1b(); |
| e2a(); |
| }''', |
| <String>["1+i1", "1+i2", "1+e1a", "1+e2a", "1+e1b"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| // Exercise import and export handling. |
| // Libraries are defined in partial order of increasing dependency. |
| sources.clear(); |
| sources["/l1.dart"] = ''' |
| library l1; |
| var _l1t; var l1t;'''; |
| buildTests( |
| 'testLibrary007', |
| ''' |
| import 'l1.dart'; |
| main() { |
| var x = l!1 |
| var y = _!2 |
| }''', |
| <String>["1+l1t", "1-_l1t", "2-_l1t"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| // Check private library exclusion |
| sources.clear(); |
| sources["/public.dart"] = ''' |
| library public; |
| class NonPrivate { |
| void publicMethod() { |
| } |
| }'''; |
| sources["/private.dart"] = ''' |
| library _private; |
| import 'public.dart'; |
| class Private extends NonPrivate { |
| void privateMethod() { |
| } |
| }'''; |
| buildTests( |
| 'testLibrary008', |
| ''' |
| import 'private.dart'; |
| import 'public.dart'; |
| class Test { |
| void test() { |
| NonPrivate x = new NonPrivate(); |
| x.!1 //publicMethod but not privateMethod should appear |
| } |
| }''', |
| <String>["1-privateMethod", "1+publicMethod"], |
| extraFiles: sources, |
| failingTests: '1'); |
| |
| // Exercise library prefixes. |
| sources.clear(); |
| sources["/lib.dart"] = ''' |
| library lib; |
| int X = 1; |
| void m(){} |
| class Y {}'''; |
| buildTests( |
| 'testLibrary009', |
| ''' |
| import 'lib.dart' as Q; |
| void a() { |
| var x = Q.!1 |
| } |
| void b() { |
| var x = [Q.!2] |
| } |
| void c() { |
| var x = new List([Q.!3]) |
| } |
| void d() { |
| new Q.!4 |
| }''', |
| <String>[ |
| "1+X", |
| "1+m", |
| "1+Y", |
| "2+X", |
| "2+m", |
| "2+Y", |
| "3+X", |
| "3+m", |
| "3+Y", |
| "4+Y", |
| "4-m", |
| "4-X" |
| ], |
| extraFiles: sources, |
| failingTests: '1234'); |
| } |
| |
| void buildNumberedTests() { |
| buildTests( |
| 'test001', |
| ''' |
| void r1(var v) { |
| v.!1toString!2().!3hash!4Code |
| }''', |
| <String>[ |
| "1+toString", |
| "1-==", |
| "2+toString", |
| "3+hashCode", |
| "3+toString", |
| "4+hashCode", |
| "4-toString" |
| ]); |
| |
| buildTests( |
| 'test002', |
| ''' |
| void r2(var vim) { |
| v!1.toString() |
| }''', |
| <String>["1+vim"]); |
| |
| buildTests( |
| 'test003', |
| ''' |
| class A { |
| int a() => 3; |
| int b() => this.!1a(); |
| }''', |
| <String>["1+a"]); |
| |
| buildTests( |
| 'test004', |
| ''' |
| class A { |
| int x; |
| A() : this.!1x = 1; |
| A.b() : this(); |
| A.c() : this.!2b(); |
| g() => new A.!3c(); |
| }''', |
| <String>["1+x", "2+b", "3+c"], |
| failingTests: '12'); |
| |
| buildTests( |
| 'test005', |
| ''' |
| class A {} |
| void rr(var vim) { |
| var !1vq = v!2.toString(); |
| var vf; |
| v!3.toString(); |
| }''', |
| <String>[ |
| "1-A", |
| "1-vim", |
| "1+vq", |
| "1-vf", |
| "1-this", |
| "1-void", |
| "1-null", |
| "1-false", |
| "2-A", |
| "2+vim", |
| "2-vf", |
| "2-vq", |
| "2-this", |
| "2-void", |
| "2-null", |
| "2-false", |
| "3+vf", |
| "3+vq", |
| "3+vim", |
| "3-A" |
| ], |
| failingTests: '1'); |
| |
| buildTests( |
| 'test006', |
| ''' |
| void r2(var vim, {va: 2, b: 3}) { |
| v!1.toString() |
| }''', |
| <String>["1+va", "1-b"]); |
| |
| buildTests( |
| 'test007', |
| ''' |
| void r2(var vim, [va: 2, b: 3]) { |
| v!1.toString() |
| }''', |
| <String>["1+va", "1-b"]); |
| |
| // keywords |
| buildTests( |
| 'test008', |
| ''' |
| !1class Aclass {} |
| class Bclass !2extends!3 !4Aclass {} |
| !5typedef Ctype = !6Bclass with !7Aclass; |
| class Dclass extends !8Ctype {} |
| !9abstract class Eclass implements Dclass,!C Ctype, Bclass {} |
| class Fclass extends Bclass !Awith !B Eclass {}''', |
| <String>[ |
| "1+class", |
| "1-implements", |
| "1-extends", |
| "1-with", |
| "2+extends", |
| "3+extends", |
| "4+Aclass", |
| "4-Bclass", |
| "5+typedef", |
| "6+Bclass", |
| "6-Ctype", |
| "7+Aclass", |
| "7-Bclass", |
| "8+Ctype", |
| "9+abstract", |
| "A+with", |
| "B+Eclass", |
| "B-Dclass", |
| "B-Ctype", |
| "C+Bclass", |
| "C-Eclass" |
| ], |
| failingTests: '23467ABC'); |
| |
| // keywords |
| buildTests( |
| 'test009', |
| ''' |
| typedef !1dy!2namic TestFn1(); |
| typedef !3vo!4id TestFn2(); |
| typ!7edef !5n!6''', |
| <String>[ |
| "1+void", |
| "1+TestFn2", |
| "2+dynamic", |
| "2-void", |
| "3+dynamic", |
| "4+void", |
| "4-dynamic", |
| "5+TestFn2", |
| "6+num", |
| "7+typedef" |
| ], |
| failingTests: '1234'); |
| |
| buildTests( |
| 'test010', |
| ''' |
| class test !8<!1t !2 !3extends String,!4 List,!5 !6>!7 {} |
| class tezetst !9<!BString,!C !DList>!A {}''', |
| <String>[ |
| "1-String", |
| "1-List", |
| "1-test", |
| "2-String", |
| "2-test", |
| "3+extends", |
| "4-tezetst", |
| "4-test", |
| "5-String", |
| "6-List", |
| "7-List", |
| "8-List", |
| "9-String", |
| "A-String", |
| "B-String", |
| "C-List", |
| "C-tezetst", |
| "D-List", |
| "D-test" |
| ], |
| failingTests: '23'); |
| |
| // name generation with conflicts |
| buildTests('test011', '''r2(var object, Object object1, Object !1);''', |
| <String>["1+object2"], |
| failingTests: '1'); |
| |
| // reserved words |
| buildTests( |
| 'test012', |
| ''' |
| class X { |
| f() { |
| g(!1var!2 z) {!3true.!4toString();}; |
| } |
| }''', |
| <String>[ |
| "1+var", |
| "1+dynamic", |
| "1-f", |
| "2+var", |
| "2-dynamic", |
| "3+false", |
| "3+true", |
| "4+toString" |
| ], |
| failingTests: '123'); |
| |
| // conditions & operators |
| buildTests( |
| 'test013', |
| ''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| var a; |
| mth() { |
| while (!1x !9); |
| do{} while(!2x !8); |
| for(z in !3zs) {} |
| switch(!4k) {case 1:{!0}} |
| try { |
| } on !5Object catch(a){} |
| if (!7x !6) {} else {}; |
| } |
| }''', |
| <String>[ |
| "1+x", |
| "2+x", |
| "3+zs", |
| "4+k", |
| "5+Q", |
| "5-a", |
| "6+==", |
| "7+x", |
| "8+==", |
| "9+==", |
| "0+k" |
| ], |
| failingTests: '689'); |
| |
| // keywords |
| buildTests( |
| 'test014', |
| ''' |
| class Q { |
| bool x; |
| List zs; |
| int k; |
| !Dvar a; |
| !Evoid mth() { |
| !1while (z) { !Gcontinue; }; |
| !2do{ !Hbreak; } !3while(x); |
| !4for(z !5in zs) {} |
| !6for (int i; i < 3; i++); |
| !7switch(k) {!8case 1:{} !9default:{}} |
| !Atry { |
| } !Bon Object !Ccatch(a){} |
| !Fassert true; |
| !Jif (x) {} !Kelse {}; |
| !Lreturn; |
| } |
| }''', |
| <String>[ |
| "1+while", |
| "2+do", |
| "3+while", |
| "4+for", |
| "5+in", |
| "6+for", |
| "7+switch", |
| "8+case", |
| "9+default", |
| "A+try", |
| "B+on", |
| "C+catch", |
| "D+var", |
| "E+void", |
| "F+assert", |
| "G+continue", |
| "H+break", |
| "J+if", |
| "K+else", |
| "L+return" |
| ], |
| failingTests: '3BCK'); |
| |
| // operators in function |
| buildTests('test015', '''f(a,b,c) => a + b * c !1;''', <String>["1+=="], |
| failingTests: '1'); |
| |
| // operators in return |
| buildTests( |
| 'test016', |
| '''class X {dynamic f(a,b,c) {return a + b * c !1;}}''', |
| <String>["1+=="], |
| failingTests: '1'); |
| |
| // keywords |
| buildTests( |
| 'test017', |
| ''' |
| !1!2import 'x' !5as r; |
| !3export '!8uri' !6hide Q !7show X; |
| !4part 'x';''', |
| <String>[ |
| "1+library", |
| "2+import", |
| "3+export", |
| "4+part", |
| "5+as", |
| "6+hide", |
| "7+show", |
| "8-null" |
| ], |
| failingTests: '567'); |
| |
| // keywords |
| buildTests('test018', '''!1part !2of foo;''', <String>["1+part", "2+of"], |
| failingTests: '2'); |
| |
| buildTests( |
| 'test019', |
| ''' |
| var truefalse = 0; |
| var falsetrue = 1; |
| main() { |
| var foo = true!1 |
| }''', |
| <String>["1+true", "1+truefalse", "1-falsetrue"]); |
| |
| buildTests('test020', '''var x = null.!1''', <String>["1+toString"], |
| failingTests: '1'); |
| |
| buildTests('test021', '''var x = .!1''', <String>["1-toString"]); |
| |
| buildTests('test022', '''var x = .!1;''', <String>["1-toString"]); |
| |
| buildTests( |
| 'test023', |
| ''' |
| class Map{getKeys(){}} |
| class X { |
| static x1(Map m) { |
| m.!1getKeys; |
| } |
| x2(Map m) { |
| m.!2getKeys; |
| } |
| }''', |
| <String>["1+getKeys", "2+getKeys"]); |
| |
| // Note lack of semicolon following completion location |
| buildTests( |
| 'test024', |
| ''' |
| class List{factory List.from(Iterable other) {}} |
| class F { |
| f() { |
| new List.!1 |
| } |
| }''', |
| <String>["1+from"]); |
| |
| buildTests( |
| 'test025', |
| ''' |
| class R { |
| static R _m; |
| static R m; |
| f() { |
| var a = !1m; |
| var b = _!2m; |
| var c = !3g(); |
| } |
| static g() { |
| var a = !4m; |
| var b = _!5m; |
| var c = !6g(); |
| } |
| } |
| class T { |
| f() { |
| R x; |
| x.!7g(); |
| x.!8m; |
| x._!9m; |
| } |
| static g() { |
| var q = R._!Am; |
| var g = R.!Bm; |
| var h = R.!Cg(); |
| } |
| h() { |
| var q = R._!Dm; |
| var g = R.!Em; |
| var h = R.!Fg(); |
| } |
| }''', |
| <String>[ |
| "1+m", |
| "2+_m", |
| "3+g", |
| "4+m", |
| "5+_m", |
| "6+g", |
| "7-g", |
| "8-m", |
| "9-_m", |
| "A+_m", |
| "B+m", |
| "C+g", |
| "D+_m", |
| "E+m", |
| "F+g" |
| ]); |
| |
| buildTests('test026', '''var aBcD; var x=ab!1''', <String>["1+aBcD"]); |
| |
| buildTests( |
| 'test027', '''m(){try{}catch(eeee,ssss){s!1}''', <String>["1+ssss"]); |
| |
| buildTests('test028', '''m(){var isX=3;if(is!1)''', <String>["1+isX"]); |
| |
| buildTests('test029', '''m(){[1].forEach((x)=>!1x);}''', <String>["1+x"]); |
| |
| buildTests('test030', '''n(){[1].forEach((x){!1});}''', <String>["1+x"]); |
| |
| buildTests( |
| 'test031', |
| '''class Caster {} m() {try {} on Cas!1ter catch (CastBlock) {!2}}''', |
| <String>["1+Caster", "1-CastBlock", "2+Caster", "2+CastBlock"]); |
| |
| buildTests( |
| 'test032', |
| ''' |
| const ONE = 1; |
| const ICHI = 10; |
| const UKSI = 100; |
| const EIN = 1000; |
| m() { |
| int x; |
| switch (x) { |
| case !3ICHI: |
| case UKSI: |
| case EIN!2: |
| case ONE!1: return; |
| default: return; |
| } |
| }''', |
| <String>[ |
| "1+ONE", |
| "1-UKSI", |
| "2+EIN", |
| "2-ICHI", |
| "3+ICHI", |
| "3+UKSI", |
| "3+EIN", |
| "3+ONE" |
| ]); |
| |
| buildTests( |
| 'test033', |
| '''class A{}class B extends A{b(){}}class C implements A {c(){}}class X{x(){A f;f.!1}}''', |
| <String>["1+b", "1-c"], |
| failingTests: '1'); |
| |
| // TODO(scheglov) decide what to do with Type for untyped field (not |
| // supported by the new store) |
| // test analysis of untyped fields and top-level vars |
| buildTests( |
| 'test034', |
| ''' |
| var topvar; |
| class Top {top(){}} |
| class Left extends Top {left(){}} |
| class Right extends Top {right(){}} |
| t1() { |
| topvar = new Left(); |
| } |
| t2() { |
| topvar = new Right(); |
| } |
| class A { |
| var field; |
| a() { |
| field = new Left(); |
| } |
| b() { |
| field = new Right(); |
| } |
| test() { |
| topvar.!1top(); |
| field.!2top(); |
| } |
| }''', |
| <String>["1+top", "2+top"], |
| failingTests: '12'); |
| |
| // test analysis of untyped fields and top-level vars |
| buildTests('test035', '''class Y {final x='hi';mth() {x.!1length;}}''', |
| <String>["1+length"]); |
| |
| // TODO(scheglov) decide what to do with Type for untyped field (not |
| // supported by the new store) |
| // test analysis of untyped fields and top-level vars |
| buildTests( |
| 'test036', |
| ''' |
| class A1 { |
| var field; |
| A1() : field = 0; |
| q() { |
| A1 a = new A1(); |
| a.field.!1 |
| } |
| } |
| main() { |
| A1 a = new A1(); |
| a.field.!2 |
| }''', |
| <String>["1+round", "2+round"], |
| failingTests: '12'); |
| |
| buildTests( |
| 'test037', |
| ''' |
| class HttpServer{} |
| class HttpClient{} |
| main() { |
| new HtS!1 |
| }''', |
| <String>["1+HttpServer", "1-HttpClient"], |
| failingTests: '1'); |
| |
| buildTests( |
| 'test038', |
| ''' |
| class X { |
| x(){} |
| } |
| class Y { |
| y(){} |
| } |
| class A<Z extends X> { |
| Y ay; |
| Z az; |
| A(this.ay, this.az) { |
| ay.!1y; |
| az.!2x; |
| } |
| }''', |
| <String>["1+y", "1-x", "2+x", "2-y"], |
| failingTests: '2'); |
| |
| // test analysis of untyped fields and top-level vars |
| buildTests('test039', '''class X{}var x = null as !1X;''', |
| <String>["1+X", "1-void"]); |
| |
| // test arg lists with named params |
| buildTests('test040', '''m(){f(a, b, {x1, x2, y}) {};f(1, 2, !1)!2;}''', |
| <String>["1+x1", "2-x2"], |
| failingTests: '1'); |
| |
| // test arg lists with named params |
| buildTests('test041', '''m(){f(a, b, {x1, x2, y}) {};f(1, 2, !1''', |
| <String>["1+x1", "1+x2", "1+y"], |
| failingTests: '1'); |
| |
| // test arg lists with named params |
| buildTests('test042', '''m(){f(a, b, {x1, x2, y}) {};f(1, 2, !1;!2''', |
| <String>["1+x1", "1+x2", "2-y"], |
| failingTests: '1'); |
| } |
| |
| void buildOtherTests() { |
| buildTests('test_classMembers_inGetter', |
| '''class A { var fff; get z {ff!1}}''', <String>["1+fff"]); |
| |
| buildTests( |
| 'testSingle', |
| '''class A {int x; !2mth() {int y = this.x;}}class B{}''', |
| <String>["2+B"]); |
| } |
| |
| /** |
| * Generate a set of completion tests based on the given [originalSource]. |
| * |
| * The source string has completion points embedded in it, which are |
| * identified by '!X' where X is a single character. Each X is matched to |
| * positive or negative results in the array of [validationStrings]. |
| * Validation strings contain the name of a prediction with a two character |
| * prefix. The first character of the prefix corresponds to an X in the |
| * [originalSource]. The second character is either a '+' or a '-' indicating |
| * whether the string is a positive or negative result. |
| * |
| * The [originalSource] is the source for a completion test that contains |
| * completion points. The [validationStrings] are the positive and negative |
| * predictions. |
| * |
| * Optional argument [failingTests], if given, is a string, each character of |
| * which corresponds to an X in the [originalSource] for which the test is |
| * expected to fail. This sould be used to mark known completion bugs that |
| * have not yet been fixed. |
| */ |
| void buildTests(String baseName, String originalSource, List<String> results, |
| {Map<String, String> extraFiles, String failingTests: ''}) { |
| List<LocationSpec> completionTests = |
| LocationSpec.from(originalSource, results); |
| completionTests.sort((LocationSpec first, LocationSpec second) { |
| return first.id.compareTo(second.id); |
| }); |
| if (completionTests.isEmpty) { |
| test(baseName, () { |
| fail("Expected exclamation point ('!') within the source denoting the" |
| "position at which code completion should occur"); |
| }); |
| } |
| Set<String> allSpecIds = |
| completionTests.map((LocationSpec spec) => spec.id).toSet(); |
| for (String id in failingTests.split('')) { |
| if (!allSpecIds.contains(id)) { |
| test("$baseName-$id", () { |
| fail( |
| "Test case '$id' included in failingTests, but this id does not exist."); |
| }); |
| } |
| } |
| for (LocationSpec spec in completionTests) { |
| String testName = '$baseName-${spec.id}'; |
| _Tester tester = testName == SOLO_TEST ? solo_test : test; |
| if (failingTests.contains(spec.id)) { |
| ++expectedFailCount; |
| tester("$testName (expected failure $expectedFailCount)", () { |
| CompletionTestCase test = new CompletionTestCase(); |
| return new Future(() => test.runTest(spec, extraFiles)).then((_) { |
| fail('Test passed - expected to fail.'); |
| }, onError: (_) {}); |
| }); |
| } else { |
| ++expectedPassCount; |
| tester(testName, () { |
| CompletionTestCase test = new CompletionTestCase(); |
| return test.runTest(spec, extraFiles); |
| }); |
| } |
| } |
| } |
| } |
