OLD | NEW |
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 library test.analysis.notification.highlights; | 5 library test.analysis.notification.highlights; |
6 | 6 |
7 import 'dart:async'; | 7 import 'dart:async'; |
8 | 8 |
9 import 'package:analysis_server/plugin/protocol/protocol.dart'; | 9 import 'package:analysis_server/plugin/protocol/protocol.dart'; |
10 import 'package:analysis_server/src/constants.dart'; | 10 import 'package:analysis_server/src/constants.dart'; |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 } | 101 } |
102 } | 102 } |
103 } | 103 } |
104 | 104 |
105 @override | 105 @override |
106 void setUp() { | 106 void setUp() { |
107 super.setUp(); | 107 super.setUp(); |
108 createProject(); | 108 createProject(); |
109 } | 109 } |
110 | 110 |
111 test_ANNOTATION_hasArguments() { | 111 test_ANNOTATION_hasArguments() async { |
112 addTestFile(''' | 112 addTestFile(''' |
113 class AAA { | 113 class AAA { |
114 const AAA(a, b, c); | 114 const AAA(a, b, c); |
115 } | 115 } |
116 @AAA(1, 2, 3) main() {} | 116 @AAA(1, 2, 3) main() {} |
117 '''); | 117 '''); |
118 return prepareHighlights().then((_) { | 118 await prepareHighlights(); |
119 assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA(', '@AAA('.length); | 119 assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA(', '@AAA('.length); |
120 assertHasRegion(HighlightRegionType.ANNOTATION, ') main', ')'.length); | 120 assertHasRegion(HighlightRegionType.ANNOTATION, ') main', ')'.length); |
121 }); | |
122 } | 121 } |
123 | 122 |
124 test_ANNOTATION_noArguments() { | 123 test_ANNOTATION_noArguments() async { |
125 addTestFile(''' | 124 addTestFile(''' |
126 const AAA = 42; | 125 const AAA = 42; |
127 @AAA main() {} | 126 @AAA main() {} |
128 '''); | 127 '''); |
129 return prepareHighlights().then((_) { | 128 await prepareHighlights(); |
130 assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA'); | 129 assertHasRegion(HighlightRegionType.ANNOTATION, '@AAA'); |
131 }); | |
132 } | 130 } |
133 | 131 |
134 test_BUILT_IN_abstract() { | 132 test_BUILT_IN_abstract() async { |
135 addTestFile(''' | 133 addTestFile(''' |
136 abstract class A {}; | 134 abstract class A {}; |
137 abstract class B = Object with A; | 135 abstract class B = Object with A; |
138 main() { | 136 main() { |
139 var abstract = 42; | 137 var abstract = 42; |
140 }'''); | 138 }'''); |
141 return prepareHighlights().then((_) { | 139 await prepareHighlights(); |
142 assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class A'); | 140 assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class A'); |
143 assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class B'); | 141 assertHasRegion(HighlightRegionType.BUILT_IN, 'abstract class B'); |
144 assertNoRegion(HighlightRegionType.BUILT_IN, 'abstract = 42'); | 142 assertNoRegion(HighlightRegionType.BUILT_IN, 'abstract = 42'); |
145 }); | |
146 } | 143 } |
147 | 144 |
148 test_BUILT_IN_as() { | 145 test_BUILT_IN_as() async { |
149 addTestFile(''' | 146 addTestFile(''' |
150 import 'dart:math' as math; | 147 import 'dart:math' as math; |
151 main() { | 148 main() { |
152 p as int; | 149 p as int; |
153 var as = 42; | 150 var as = 42; |
154 }'''); | 151 }'''); |
155 return prepareHighlights().then((_) { | 152 await prepareHighlights(); |
156 assertHasRegion(HighlightRegionType.BUILT_IN, 'as math'); | 153 assertHasRegion(HighlightRegionType.BUILT_IN, 'as math'); |
157 assertHasRegion(HighlightRegionType.BUILT_IN, 'as int'); | 154 assertHasRegion(HighlightRegionType.BUILT_IN, 'as int'); |
158 assertNoRegion(HighlightRegionType.BUILT_IN, 'as = 42'); | 155 assertNoRegion(HighlightRegionType.BUILT_IN, 'as = 42'); |
159 }); | |
160 } | 156 } |
161 | 157 |
162 test_BUILT_IN_async() { | 158 test_BUILT_IN_async() async { |
163 addTestFile(''' | 159 addTestFile(''' |
164 fa() async {} | 160 fa() async {} |
165 fb() async* {} | 161 fb() async* {} |
166 main() { | 162 main() { |
167 bool async = false; | 163 bool async = false; |
168 } | 164 } |
169 '''); | 165 '''); |
170 return prepareHighlights().then((_) { | 166 await prepareHighlights(); |
171 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async'); | 167 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async'); |
172 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async*'); | 168 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'async*'); |
173 assertNoRegion(HighlightRegionType.BUILT_IN, 'async = false'); | 169 assertNoRegion(HighlightRegionType.BUILT_IN, 'async = false'); |
174 }); | |
175 } | 170 } |
176 | 171 |
177 test_BUILT_IN_await() { | 172 test_BUILT_IN_await() async { |
178 addTestFile(''' | 173 addTestFile(''' |
179 main() async { | 174 main() async { |
180 await 42; | 175 await 42; |
181 await for (var item in []) { | 176 await for (var item in []) { |
182 print(item); | 177 print(item); |
183 } | 178 } |
184 } | 179 } |
185 '''); | 180 '''); |
186 return prepareHighlights().then((_) { | 181 await prepareHighlights(); |
187 assertHasRegion(HighlightRegionType.BUILT_IN, 'await 42'); | 182 assertHasRegion(HighlightRegionType.BUILT_IN, 'await 42'); |
188 assertHasRegion(HighlightRegionType.BUILT_IN, 'await for'); | 183 assertHasRegion(HighlightRegionType.BUILT_IN, 'await for'); |
189 }); | |
190 } | 184 } |
191 | 185 |
192 test_BUILT_IN_deferred() { | 186 test_BUILT_IN_deferred() async { |
193 addTestFile(''' | 187 addTestFile(''' |
194 import 'dart:math' deferred as math; | 188 import 'dart:math' deferred as math; |
195 main() { | 189 main() { |
196 var deferred = 42; | 190 var deferred = 42; |
197 }'''); | 191 }'''); |
198 return prepareHighlights().then((_) { | 192 await prepareHighlights(); |
199 assertHasRegion(HighlightRegionType.BUILT_IN, 'deferred as math'); | 193 assertHasRegion(HighlightRegionType.BUILT_IN, 'deferred as math'); |
200 assertNoRegion(HighlightRegionType.BUILT_IN, 'deferred = 42'); | 194 assertNoRegion(HighlightRegionType.BUILT_IN, 'deferred = 42'); |
201 }); | |
202 } | 195 } |
203 | 196 |
204 test_BUILT_IN_export() { | 197 test_BUILT_IN_export() async { |
205 addTestFile(''' | 198 addTestFile(''' |
206 export "dart:math"; | 199 export "dart:math"; |
207 main() { | 200 main() { |
208 var export = 42; | 201 var export = 42; |
209 }'''); | 202 }'''); |
210 return prepareHighlights().then((_) { | 203 await prepareHighlights(); |
211 assertHasRegion(HighlightRegionType.BUILT_IN, 'export "dart:'); | 204 assertHasRegion(HighlightRegionType.BUILT_IN, 'export "dart:'); |
212 assertNoRegion(HighlightRegionType.BUILT_IN, 'export = 42'); | 205 assertNoRegion(HighlightRegionType.BUILT_IN, 'export = 42'); |
213 }); | |
214 } | 206 } |
215 | 207 |
216 test_BUILT_IN_external() { | 208 test_BUILT_IN_external() async { |
217 addTestFile(''' | 209 addTestFile(''' |
218 class A { | 210 class A { |
219 external A(); | 211 external A(); |
220 external aaa(); | 212 external aaa(); |
221 } | 213 } |
222 external main() { | 214 external main() { |
223 var external = 42; | 215 var external = 42; |
224 }'''); | 216 }'''); |
225 return prepareHighlights().then((_) { | 217 await prepareHighlights(); |
226 assertHasRegion(HighlightRegionType.BUILT_IN, 'external A()'); | 218 assertHasRegion(HighlightRegionType.BUILT_IN, 'external A()'); |
227 assertHasRegion(HighlightRegionType.BUILT_IN, 'external aaa()'); | 219 assertHasRegion(HighlightRegionType.BUILT_IN, 'external aaa()'); |
228 assertHasRegion(HighlightRegionType.BUILT_IN, 'external main()'); | 220 assertHasRegion(HighlightRegionType.BUILT_IN, 'external main()'); |
229 assertNoRegion(HighlightRegionType.BUILT_IN, 'external = 42'); | 221 assertNoRegion(HighlightRegionType.BUILT_IN, 'external = 42'); |
230 }); | |
231 } | 222 } |
232 | 223 |
233 test_BUILT_IN_factory() { | 224 test_BUILT_IN_factory() async { |
234 addTestFile(''' | 225 addTestFile(''' |
235 class A { | 226 class A { |
236 factory A() => null; | 227 factory A() => null; |
237 } | 228 } |
238 main() { | 229 main() { |
239 var factory = 42; | 230 var factory = 42; |
240 }'''); | 231 }'''); |
241 return prepareHighlights().then((_) { | 232 await prepareHighlights(); |
242 assertHasRegion(HighlightRegionType.BUILT_IN, 'factory A()'); | 233 assertHasRegion(HighlightRegionType.BUILT_IN, 'factory A()'); |
243 assertNoRegion(HighlightRegionType.BUILT_IN, 'factory = 42'); | 234 assertNoRegion(HighlightRegionType.BUILT_IN, 'factory = 42'); |
244 }); | |
245 } | 235 } |
246 | 236 |
247 test_BUILT_IN_get() { | 237 test_BUILT_IN_get() async { |
248 addTestFile(''' | 238 addTestFile(''' |
249 get aaa => 1; | 239 get aaa => 1; |
250 class A { | 240 class A { |
251 get bbb => 2; | 241 get bbb => 2; |
252 } | 242 } |
253 main() { | 243 main() { |
254 var get = 42; | 244 var get = 42; |
255 }'''); | 245 }'''); |
256 return prepareHighlights().then((_) { | 246 await prepareHighlights(); |
257 assertHasRegion(HighlightRegionType.BUILT_IN, 'get aaa =>'); | 247 assertHasRegion(HighlightRegionType.BUILT_IN, 'get aaa =>'); |
258 assertHasRegion(HighlightRegionType.BUILT_IN, 'get bbb =>'); | 248 assertHasRegion(HighlightRegionType.BUILT_IN, 'get bbb =>'); |
259 assertNoRegion(HighlightRegionType.BUILT_IN, 'get = 42'); | 249 assertNoRegion(HighlightRegionType.BUILT_IN, 'get = 42'); |
260 }); | |
261 } | 250 } |
262 | 251 |
263 test_BUILT_IN_hide() { | 252 test_BUILT_IN_hide() async { |
264 addTestFile(''' | 253 addTestFile(''' |
265 import 'foo.dart' hide Foo; | 254 import 'foo.dart' hide Foo; |
266 main() { | 255 main() { |
267 var hide = 42; | 256 var hide = 42; |
268 }'''); | 257 }'''); |
269 return prepareHighlights().then((_) { | 258 await prepareHighlights(); |
270 assertHasRegion(HighlightRegionType.BUILT_IN, 'hide Foo'); | 259 assertHasRegion(HighlightRegionType.BUILT_IN, 'hide Foo'); |
271 assertNoRegion(HighlightRegionType.BUILT_IN, 'hide = 42'); | 260 assertNoRegion(HighlightRegionType.BUILT_IN, 'hide = 42'); |
272 }); | |
273 } | 261 } |
274 | 262 |
275 test_BUILT_IN_implements() { | 263 test_BUILT_IN_implements() async { |
276 addTestFile(''' | 264 addTestFile(''' |
277 class A {} | 265 class A {} |
278 class B implements A {} | 266 class B implements A {} |
279 main() { | 267 main() { |
280 var implements = 42; | 268 var implements = 42; |
281 }'''); | 269 }'''); |
282 return prepareHighlights().then((_) { | 270 await prepareHighlights(); |
283 assertHasRegion(HighlightRegionType.BUILT_IN, 'implements A {}'); | 271 assertHasRegion(HighlightRegionType.BUILT_IN, 'implements A {}'); |
284 assertNoRegion(HighlightRegionType.BUILT_IN, 'implements = 42'); | 272 assertNoRegion(HighlightRegionType.BUILT_IN, 'implements = 42'); |
285 }); | |
286 } | 273 } |
287 | 274 |
288 test_BUILT_IN_import() { | 275 test_BUILT_IN_import() async { |
289 addTestFile(''' | 276 addTestFile(''' |
290 import "foo.dart"; | 277 import "foo.dart"; |
291 main() { | 278 main() { |
292 var import = 42; | 279 var import = 42; |
293 }'''); | 280 }'''); |
294 return prepareHighlights().then((_) { | 281 await prepareHighlights(); |
295 assertHasRegion(HighlightRegionType.BUILT_IN, 'import "'); | 282 assertHasRegion(HighlightRegionType.BUILT_IN, 'import "'); |
296 assertNoRegion(HighlightRegionType.BUILT_IN, 'import = 42'); | 283 assertNoRegion(HighlightRegionType.BUILT_IN, 'import = 42'); |
297 }); | |
298 } | 284 } |
299 | 285 |
300 test_BUILT_IN_library() { | 286 test_BUILT_IN_library() async { |
301 addTestFile(''' | 287 addTestFile(''' |
302 library lib; | 288 library lib; |
303 main() { | 289 main() { |
304 var library = 42; | 290 var library = 42; |
305 }'''); | 291 }'''); |
306 return prepareHighlights().then((_) { | 292 await prepareHighlights(); |
307 assertHasRegion(HighlightRegionType.BUILT_IN, 'library lib;'); | 293 assertHasRegion(HighlightRegionType.BUILT_IN, 'library lib;'); |
308 assertNoRegion(HighlightRegionType.BUILT_IN, 'library = 42'); | 294 assertNoRegion(HighlightRegionType.BUILT_IN, 'library = 42'); |
309 }); | |
310 } | 295 } |
311 | 296 |
312 test_BUILT_IN_native() { | 297 test_BUILT_IN_native() async { |
313 addTestFile(''' | 298 addTestFile(''' |
314 class A native "A_native" {} | 299 class A native "A_native" {} |
315 class B { | 300 class B { |
316 bbb() native "bbb_native"; | 301 bbb() native "bbb_native"; |
317 } | 302 } |
318 main() { | 303 main() { |
319 var native = 42; | 304 var native = 42; |
320 }'''); | 305 }'''); |
321 return prepareHighlights().then((_) { | 306 await prepareHighlights(); |
322 assertHasRegion(HighlightRegionType.BUILT_IN, 'native "A_'); | 307 assertHasRegion(HighlightRegionType.BUILT_IN, 'native "A_'); |
323 assertHasRegion(HighlightRegionType.BUILT_IN, 'native "bbb_'); | 308 assertHasRegion(HighlightRegionType.BUILT_IN, 'native "bbb_'); |
324 assertNoRegion(HighlightRegionType.BUILT_IN, 'native = 42'); | 309 assertNoRegion(HighlightRegionType.BUILT_IN, 'native = 42'); |
325 }); | |
326 } | 310 } |
327 | 311 |
328 test_BUILT_IN_on() { | 312 test_BUILT_IN_on() async { |
329 addTestFile(''' | 313 addTestFile(''' |
330 main() { | 314 main() { |
331 try { | 315 try { |
332 } on int catch (e) { | 316 } on int catch (e) { |
333 } | 317 } |
334 var on = 42; | 318 var on = 42; |
335 }'''); | 319 }'''); |
336 return prepareHighlights().then((_) { | 320 await prepareHighlights(); |
337 assertHasRegion(HighlightRegionType.BUILT_IN, 'on int'); | 321 assertHasRegion(HighlightRegionType.BUILT_IN, 'on int'); |
338 assertNoRegion(HighlightRegionType.BUILT_IN, 'on = 42'); | 322 assertNoRegion(HighlightRegionType.BUILT_IN, 'on = 42'); |
339 }); | |
340 } | 323 } |
341 | 324 |
342 test_BUILT_IN_operator() { | 325 test_BUILT_IN_operator() async { |
343 addTestFile(''' | 326 addTestFile(''' |
344 class A { | 327 class A { |
345 operator +(x) => null; | 328 operator +(x) => null; |
346 } | 329 } |
347 main() { | 330 main() { |
348 var operator = 42; | 331 var operator = 42; |
349 }'''); | 332 }'''); |
350 return prepareHighlights().then((_) { | 333 await prepareHighlights(); |
351 assertHasRegion(HighlightRegionType.BUILT_IN, 'operator +('); | 334 assertHasRegion(HighlightRegionType.BUILT_IN, 'operator +('); |
352 assertNoRegion(HighlightRegionType.BUILT_IN, 'operator = 42'); | 335 assertNoRegion(HighlightRegionType.BUILT_IN, 'operator = 42'); |
353 }); | |
354 } | 336 } |
355 | 337 |
356 test_BUILT_IN_part() { | 338 test_BUILT_IN_part() async { |
357 addTestFile(''' | 339 addTestFile(''' |
358 part "my_part.dart"; | 340 part "my_part.dart"; |
359 main() { | 341 main() { |
360 var part = 42; | 342 var part = 42; |
361 }'''); | 343 }'''); |
362 addFile('/project/bin/my_part.dart', 'part of lib;'); | 344 addFile('/project/bin/my_part.dart', 'part of lib;'); |
363 return prepareHighlights().then((_) { | 345 await prepareHighlights(); |
364 assertHasRegion(HighlightRegionType.BUILT_IN, 'part "my_'); | 346 assertHasRegion(HighlightRegionType.BUILT_IN, 'part "my_'); |
365 assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 42'); | 347 assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 42'); |
366 }); | |
367 } | 348 } |
368 | 349 |
369 test_BUILT_IN_partOf() { | 350 test_BUILT_IN_partOf() async { |
370 addTestFile(''' | 351 addTestFile(''' |
371 part of lib; | 352 part of lib; |
372 main() { | 353 main() { |
373 var part = 1; | 354 var part = 1; |
374 var of = 2; | 355 var of = 2; |
375 }'''); | 356 }'''); |
376 _addLibraryForTestPart(); | 357 _addLibraryForTestPart(); |
377 return prepareHighlights().then((_) { | 358 await prepareHighlights(); |
378 assertHasRegion( | 359 assertHasRegion(HighlightRegionType.BUILT_IN, 'part of', 'part of'.length); |
379 HighlightRegionType.BUILT_IN, 'part of', 'part of'.length); | 360 assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 1'); |
380 assertNoRegion(HighlightRegionType.BUILT_IN, 'part = 1'); | 361 assertNoRegion(HighlightRegionType.BUILT_IN, 'of = 2'); |
381 assertNoRegion(HighlightRegionType.BUILT_IN, 'of = 2'); | |
382 }); | |
383 } | 362 } |
384 | 363 |
385 test_BUILT_IN_set() { | 364 test_BUILT_IN_set() async { |
386 addTestFile(''' | 365 addTestFile(''' |
387 set aaa(x) {} | 366 set aaa(x) {} |
388 class A | 367 class A |
389 set bbb(x) {} | 368 set bbb(x) {} |
390 } | 369 } |
391 main() { | 370 main() { |
392 var set = 42; | 371 var set = 42; |
393 }'''); | 372 }'''); |
394 return prepareHighlights().then((_) { | 373 await prepareHighlights(); |
395 assertHasRegion(HighlightRegionType.BUILT_IN, 'set aaa('); | 374 assertHasRegion(HighlightRegionType.BUILT_IN, 'set aaa('); |
396 assertHasRegion(HighlightRegionType.BUILT_IN, 'set bbb('); | 375 assertHasRegion(HighlightRegionType.BUILT_IN, 'set bbb('); |
397 assertNoRegion(HighlightRegionType.BUILT_IN, 'set = 42'); | 376 assertNoRegion(HighlightRegionType.BUILT_IN, 'set = 42'); |
398 }); | |
399 } | 377 } |
400 | 378 |
401 test_BUILT_IN_show() { | 379 test_BUILT_IN_show() async { |
402 addTestFile(''' | 380 addTestFile(''' |
403 import 'foo.dart' show Foo; | 381 import 'foo.dart' show Foo; |
404 main() { | 382 main() { |
405 var show = 42; | 383 var show = 42; |
406 }'''); | 384 }'''); |
407 return prepareHighlights().then((_) { | 385 await prepareHighlights(); |
408 assertHasRegion(HighlightRegionType.BUILT_IN, 'show Foo'); | 386 assertHasRegion(HighlightRegionType.BUILT_IN, 'show Foo'); |
409 assertNoRegion(HighlightRegionType.BUILT_IN, 'show = 42'); | 387 assertNoRegion(HighlightRegionType.BUILT_IN, 'show = 42'); |
410 }); | |
411 } | 388 } |
412 | 389 |
413 test_BUILT_IN_static() { | 390 test_BUILT_IN_static() async { |
414 addTestFile(''' | 391 addTestFile(''' |
415 class A { | 392 class A { |
416 static aaa; | 393 static aaa; |
417 static bbb() {} | 394 static bbb() {} |
418 } | 395 } |
419 main() { | 396 main() { |
420 var static = 42; | 397 var static = 42; |
421 }'''); | 398 }'''); |
422 return prepareHighlights().then((_) { | 399 await prepareHighlights(); |
423 assertHasRegion(HighlightRegionType.BUILT_IN, 'static aaa;'); | 400 assertHasRegion(HighlightRegionType.BUILT_IN, 'static aaa;'); |
424 assertHasRegion(HighlightRegionType.BUILT_IN, 'static bbb()'); | 401 assertHasRegion(HighlightRegionType.BUILT_IN, 'static bbb()'); |
425 assertNoRegion(HighlightRegionType.BUILT_IN, 'static = 42'); | 402 assertNoRegion(HighlightRegionType.BUILT_IN, 'static = 42'); |
426 }); | |
427 } | 403 } |
428 | 404 |
429 test_BUILT_IN_sync() { | 405 test_BUILT_IN_sync() async { |
430 addTestFile(''' | 406 addTestFile(''' |
431 fa() sync {} | 407 fa() sync {} |
432 fb() sync* {} | 408 fb() sync* {} |
433 main() { | 409 main() { |
434 bool sync = false; | 410 bool sync = false; |
435 } | 411 } |
436 '''); | 412 '''); |
437 return prepareHighlights().then((_) { | 413 await prepareHighlights(); |
438 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync'); | 414 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync'); |
439 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync*'); | 415 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'sync*'); |
440 assertNoRegion(HighlightRegionType.BUILT_IN, 'sync = false'); | 416 assertNoRegion(HighlightRegionType.BUILT_IN, 'sync = false'); |
441 }); | |
442 } | 417 } |
443 | 418 |
444 test_BUILT_IN_typedef() { | 419 test_BUILT_IN_typedef() async { |
445 addTestFile(''' | 420 addTestFile(''' |
446 typedef A(); | 421 typedef A(); |
447 main() { | 422 main() { |
448 var typedef = 42; | 423 var typedef = 42; |
449 }'''); | 424 }'''); |
450 return prepareHighlights().then((_) { | 425 await prepareHighlights(); |
451 assertHasRegion(HighlightRegionType.BUILT_IN, 'typedef A();'); | 426 assertHasRegion(HighlightRegionType.BUILT_IN, 'typedef A();'); |
452 assertNoRegion(HighlightRegionType.BUILT_IN, 'typedef = 42'); | 427 assertNoRegion(HighlightRegionType.BUILT_IN, 'typedef = 42'); |
453 }); | |
454 } | 428 } |
455 | 429 |
456 test_BUILT_IN_yield() { | 430 test_BUILT_IN_yield() async { |
457 addTestFile(''' | 431 addTestFile(''' |
458 main() async* { | 432 main() async* { |
459 yield 42; | 433 yield 42; |
460 } | 434 } |
461 '''); | 435 '''); |
462 return prepareHighlights().then((_) { | 436 await prepareHighlights(); |
463 assertHasRegion(HighlightRegionType.BUILT_IN, 'yield 42'); | 437 assertHasRegion(HighlightRegionType.BUILT_IN, 'yield 42'); |
464 }); | |
465 } | 438 } |
466 | 439 |
467 test_BUILT_IN_yieldStar() { | 440 test_BUILT_IN_yieldStar() async { |
468 addTestFile(''' | 441 addTestFile(''' |
469 main() async* { | 442 main() async* { |
470 yield* []; | 443 yield* []; |
471 } | 444 } |
472 '''); | 445 '''); |
473 return prepareHighlights().then((_) { | 446 await prepareHighlights(); |
474 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'yield*'); | 447 assertHasStringRegion(HighlightRegionType.BUILT_IN, 'yield*'); |
475 }); | |
476 } | 448 } |
477 | 449 |
478 test_CLASS() { | 450 test_CLASS() async { |
479 addTestFile(''' | 451 addTestFile(''' |
480 class AAA {} | 452 class AAA {} |
481 AAA aaa; | 453 AAA aaa; |
482 '''); | 454 '''); |
483 return prepareHighlights().then((_) { | 455 await prepareHighlights(); |
484 assertHasRegion(HighlightRegionType.CLASS, 'AAA {}'); | 456 assertHasRegion(HighlightRegionType.CLASS, 'AAA {}'); |
485 assertHasRegion(HighlightRegionType.CLASS, 'AAA aaa'); | 457 assertHasRegion(HighlightRegionType.CLASS, 'AAA aaa'); |
486 }); | |
487 } | 458 } |
488 | 459 |
489 test_CLASS_notDynamic() { | 460 test_CLASS_notDynamic() async { |
490 addTestFile(''' | 461 addTestFile(''' |
491 dynamic f() {} | 462 dynamic f() {} |
492 '''); | 463 '''); |
493 return prepareHighlights().then((_) { | 464 await prepareHighlights(); |
494 assertNoRegion(HighlightRegionType.CLASS, 'dynamic f()'); | 465 assertNoRegion(HighlightRegionType.CLASS, 'dynamic f()'); |
495 }); | |
496 } | 466 } |
497 | 467 |
498 test_CLASS_notVoid() { | 468 test_CLASS_notVoid() async { |
499 addTestFile(''' | 469 addTestFile(''' |
500 void f() {} | 470 void f() {} |
501 '''); | 471 '''); |
502 return prepareHighlights().then((_) { | 472 await prepareHighlights(); |
503 assertNoRegion(HighlightRegionType.CLASS, 'void f()'); | 473 assertNoRegion(HighlightRegionType.CLASS, 'void f()'); |
504 }); | |
505 } | 474 } |
506 | 475 |
507 test_COMMENT() { | 476 test_COMMENT() async { |
508 addTestFile(''' | 477 addTestFile(''' |
509 /** | 478 /** |
510 * documentation comment | 479 * documentation comment |
511 */ | 480 */ |
512 void main() { | 481 void main() { |
513 // end-of-line comment | 482 // end-of-line comment |
514 my_function(1); | 483 my_function(1); |
515 } | 484 } |
516 | 485 |
517 void my_function(String a) { | 486 void my_function(String a) { |
518 /* block comment */ | 487 /* block comment */ |
519 } | 488 } |
520 '''); | 489 '''); |
521 return prepareHighlights().then((_) { | 490 await prepareHighlights(); |
522 assertHasRegion(HighlightRegionType.COMMENT_DOCUMENTATION, '/**', 32); | 491 assertHasRegion(HighlightRegionType.COMMENT_DOCUMENTATION, '/**', 32); |
523 assertHasRegion(HighlightRegionType.COMMENT_END_OF_LINE, '//', 22); | 492 assertHasRegion(HighlightRegionType.COMMENT_END_OF_LINE, '//', 22); |
524 assertHasRegion(HighlightRegionType.COMMENT_BLOCK, '/* b', 19); | 493 assertHasRegion(HighlightRegionType.COMMENT_BLOCK, '/* b', 19); |
525 }); | |
526 } | 494 } |
527 | 495 |
528 test_CONSTRUCTOR() { | 496 test_CONSTRUCTOR() async { |
529 addTestFile(''' | 497 addTestFile(''' |
530 class AAA { | 498 class AAA { |
531 AAA() {} | 499 AAA() {} |
532 AAA.name(p) {} | 500 AAA.name(p) {} |
533 } | 501 } |
534 main() { | 502 main() { |
535 new AAA(); | 503 new AAA(); |
536 new AAA.name(42); | 504 new AAA.name(42); |
537 } | 505 } |
538 '''); | 506 '''); |
539 return prepareHighlights().then((_) { | 507 await prepareHighlights(); |
540 assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(p)'); | 508 assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(p)'); |
541 assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(42)'); | 509 assertHasRegion(HighlightRegionType.CONSTRUCTOR, 'name(42)'); |
542 assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA() {}'); | 510 assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA() {}'); |
543 assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA();'); | 511 assertNoRegion(HighlightRegionType.CONSTRUCTOR, 'AAA();'); |
544 }); | |
545 } | 512 } |
546 | 513 |
547 test_DIRECTIVE() { | 514 test_DIRECTIVE() async { |
548 addTestFile(''' | 515 addTestFile(''' |
549 library lib; | 516 library lib; |
550 import 'dart:math'; | 517 import 'dart:math'; |
551 export 'dart:math'; | 518 export 'dart:math'; |
552 part 'part.dart'; | 519 part 'part.dart'; |
553 '''); | 520 '''); |
554 return prepareHighlights().then((_) { | 521 await prepareHighlights(); |
555 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "library lib;"); | 522 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "library lib;"); |
556 assertHasStringRegion( | 523 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "import 'dart:math';"); |
557 HighlightRegionType.DIRECTIVE, "import 'dart:math';"); | 524 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "export 'dart:math';"); |
558 assertHasStringRegion( | 525 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part 'part.dart';"); |
559 HighlightRegionType.DIRECTIVE, "export 'dart:math';"); | |
560 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part 'part.dart';"); | |
561 }); | |
562 } | 526 } |
563 | 527 |
564 test_DIRECTIVE_partOf() { | 528 test_DIRECTIVE_partOf() async { |
565 addTestFile(''' | 529 addTestFile(''' |
566 part of lib; | 530 part of lib; |
567 '''); | 531 '''); |
568 _addLibraryForTestPart(); | 532 _addLibraryForTestPart(); |
569 return prepareHighlights().then((_) { | 533 await prepareHighlights(); |
570 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part of lib;"); | 534 assertHasStringRegion(HighlightRegionType.DIRECTIVE, "part of lib;"); |
571 }); | |
572 } | 535 } |
573 | 536 |
574 test_DYNAMIC_TYPE() { | 537 test_DYNAMIC_TYPE() async { |
575 addTestFile(''' | 538 addTestFile(''' |
576 f() {} | 539 f() {} |
577 main(p) { | 540 main(p) { |
578 print(p); | 541 print(p); |
579 var v1 = f(); | 542 var v1 = f(); |
580 int v2; | 543 int v2; |
581 var v3 = v2; | 544 var v3 = v2; |
582 } | 545 } |
583 '''); | 546 '''); |
584 return prepareHighlights().then((_) { | 547 await prepareHighlights(); |
585 assertHasRegion(HighlightRegionType.DYNAMIC_TYPE, 'p)'); | 548 assertHasRegion(HighlightRegionType.DYNAMIC_TYPE, 'p)'); |
586 assertHasRegion(HighlightRegionType.DYNAMIC_TYPE, 'v1 ='); | 549 assertHasRegion(HighlightRegionType.DYNAMIC_TYPE, 'v1 ='); |
587 assertNoRegion(HighlightRegionType.DYNAMIC_TYPE, 'v2;'); | 550 assertNoRegion(HighlightRegionType.DYNAMIC_TYPE, 'v2;'); |
588 assertNoRegion(HighlightRegionType.DYNAMIC_TYPE, 'v3 ='); | 551 assertNoRegion(HighlightRegionType.DYNAMIC_TYPE, 'v3 ='); |
589 }); | |
590 } | 552 } |
591 | 553 |
592 test_ENUM() { | 554 test_ENUM() async { |
593 addTestFile(''' | 555 addTestFile(''' |
594 enum MyEnum {A, B, C} | 556 enum MyEnum {A, B, C} |
595 MyEnum value; | 557 MyEnum value; |
596 '''); | 558 '''); |
597 return prepareHighlights().then((_) { | 559 await prepareHighlights(); |
598 assertHasRegion(HighlightRegionType.ENUM, 'MyEnum {'); | 560 assertHasRegion(HighlightRegionType.ENUM, 'MyEnum {'); |
599 assertHasRegion(HighlightRegionType.ENUM, 'MyEnum value;'); | 561 assertHasRegion(HighlightRegionType.ENUM, 'MyEnum value;'); |
600 }); | |
601 } | 562 } |
602 | 563 |
603 test_ENUM_CONSTANT() { | 564 test_ENUM_CONSTANT() async { |
604 addTestFile(''' | 565 addTestFile(''' |
605 enum MyEnum {AAA, BBB} | 566 enum MyEnum {AAA, BBB} |
606 main() { | 567 main() { |
607 print(MyEnum.AAA); | 568 print(MyEnum.AAA); |
608 print(MyEnum.BBB); | 569 print(MyEnum.BBB); |
609 } | 570 } |
610 '''); | 571 '''); |
611 return prepareHighlights().then((_) { | 572 await prepareHighlights(); |
612 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA, '); | 573 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA, '); |
613 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB}'); | 574 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB}'); |
614 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA);'); | 575 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'AAA);'); |
615 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB);'); | 576 assertHasRegion(HighlightRegionType.ENUM_CONSTANT, 'BBB);'); |
616 }); | |
617 } | 577 } |
618 | 578 |
619 test_FIELD() { | 579 test_FIELD() async { |
620 addTestFile(''' | 580 addTestFile(''' |
621 class A { | 581 class A { |
622 int aaa = 1; | 582 int aaa = 1; |
623 int bbb = 2; | 583 int bbb = 2; |
624 A([this.bbb = 3]); | 584 A([this.bbb = 3]); |
625 } | 585 } |
626 main(A a) { | 586 main(A a) { |
627 a.aaa = 4; | 587 a.aaa = 4; |
628 a.bbb = 5; | 588 a.bbb = 5; |
629 } | 589 } |
630 '''); | 590 '''); |
631 return prepareHighlights().then((_) { | 591 await prepareHighlights(); |
632 assertHasRegion(HighlightRegionType.FIELD, 'aaa = 1'); | 592 assertHasRegion(HighlightRegionType.FIELD, 'aaa = 1'); |
633 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 2'); | 593 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 2'); |
634 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 3'); | 594 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 3'); |
635 assertHasRegion(HighlightRegionType.FIELD, 'aaa = 4'); | 595 assertHasRegion(HighlightRegionType.FIELD, 'aaa = 4'); |
636 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 5'); | 596 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 5'); |
637 }); | |
638 } | 597 } |
639 | 598 |
640 test_FIELD_STATIC() { | 599 test_FIELD_STATIC() async { |
641 addTestFile(''' | 600 addTestFile(''' |
642 class A { | 601 class A { |
643 static aaa = 1; | 602 static aaa = 1; |
644 static get bbb => null; | 603 static get bbb => null; |
645 static set ccc(x) {} | 604 static set ccc(x) {} |
646 } | 605 } |
647 main() { | 606 main() { |
648 A.aaa = 2; | 607 A.aaa = 2; |
649 A.bbb; | 608 A.bbb; |
650 A.ccc = 3; | 609 A.ccc = 3; |
651 } | 610 } |
652 '''); | 611 '''); |
653 return prepareHighlights().then((_) { | 612 await prepareHighlights(); |
654 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'aaa = 1'); | 613 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'aaa = 1'); |
655 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'aaa = 2'); | 614 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'aaa = 2'); |
656 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'bbb;'); | 615 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'bbb;'); |
657 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'ccc = 3'); | 616 assertHasRegion(HighlightRegionType.FIELD_STATIC, 'ccc = 3'); |
658 }); | |
659 } | 617 } |
660 | 618 |
661 test_FUNCTION() { | 619 test_FUNCTION() async { |
662 addTestFile(''' | 620 addTestFile(''' |
663 fff(p) {} | 621 fff(p) {} |
664 main() { | 622 main() { |
665 fff(42); | 623 fff(42); |
666 } | 624 } |
667 '''); | 625 '''); |
668 return prepareHighlights().then((_) { | 626 await prepareHighlights(); |
669 assertHasRegion(HighlightRegionType.FUNCTION_DECLARATION, 'fff(p) {}'); | 627 assertHasRegion(HighlightRegionType.FUNCTION_DECLARATION, 'fff(p) {}'); |
670 assertHasRegion(HighlightRegionType.FUNCTION, 'fff(42)'); | 628 assertHasRegion(HighlightRegionType.FUNCTION, 'fff(42)'); |
671 }); | |
672 } | 629 } |
673 | 630 |
674 test_FUNCTION_TYPE_ALIAS() { | 631 test_FUNCTION_TYPE_ALIAS() async { |
675 addTestFile(''' | 632 addTestFile(''' |
676 typedef FFF(p); | 633 typedef FFF(p); |
677 main(FFF fff) { | 634 main(FFF fff) { |
678 } | 635 } |
679 '''); | 636 '''); |
680 return prepareHighlights().then((_) { | 637 await prepareHighlights(); |
681 assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF(p)'); | 638 assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF(p)'); |
682 assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF fff)'); | 639 assertHasRegion(HighlightRegionType.FUNCTION_TYPE_ALIAS, 'FFF fff)'); |
683 }); | |
684 } | 640 } |
685 | 641 |
686 test_GETTER_DECLARATION() { | 642 test_GETTER_DECLARATION() async { |
687 addTestFile(''' | 643 addTestFile(''' |
688 get aaa => null; | 644 get aaa => null; |
689 class A { | 645 class A { |
690 get bbb => null; | 646 get bbb => null; |
691 } | 647 } |
692 main(A a) { | 648 main(A a) { |
693 aaa; | 649 aaa; |
694 a.bbb; | 650 a.bbb; |
695 } | 651 } |
696 '''); | 652 '''); |
697 return prepareHighlights().then((_) { | 653 await prepareHighlights(); |
698 assertHasRegion(HighlightRegionType.GETTER_DECLARATION, 'aaa => null'); | 654 assertHasRegion(HighlightRegionType.GETTER_DECLARATION, 'aaa => null'); |
699 assertHasRegion(HighlightRegionType.GETTER_DECLARATION, 'bbb => null'); | 655 assertHasRegion(HighlightRegionType.GETTER_DECLARATION, 'bbb => null'); |
700 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'aaa;'); | 656 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'aaa;'); |
701 assertHasRegion(HighlightRegionType.FIELD, 'bbb;'); | 657 assertHasRegion(HighlightRegionType.FIELD, 'bbb;'); |
702 }); | |
703 } | 658 } |
704 | 659 |
705 test_IDENTIFIER_DEFAULT() { | 660 test_IDENTIFIER_DEFAULT() async { |
706 addTestFile(''' | 661 addTestFile(''' |
707 main() { | 662 main() { |
708 aaa = 42; | 663 aaa = 42; |
709 bbb(84); | 664 bbb(84); |
710 CCC ccc; | 665 CCC ccc; |
711 } | 666 } |
712 '''); | 667 '''); |
713 return prepareHighlights().then((_) { | 668 await prepareHighlights(); |
714 assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'aaa = 42'); | 669 assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'aaa = 42'); |
715 assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'bbb(84)'); | 670 assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'bbb(84)'); |
716 assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'CCC ccc'); | 671 assertHasRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'CCC ccc'); |
717 }); | |
718 } | 672 } |
719 | 673 |
720 test_IMPORT_PREFIX() { | 674 test_IMPORT_PREFIX() async { |
721 addTestFile(''' | 675 addTestFile(''' |
722 import 'dart:math' as ma; | 676 import 'dart:math' as ma; |
723 main() { | 677 main() { |
724 ma.max(1, 2); | 678 ma.max(1, 2); |
725 } | 679 } |
726 '''); | 680 '''); |
727 return prepareHighlights().then((_) { | 681 await prepareHighlights(); |
728 assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma;'); | 682 assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma;'); |
729 assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma.max'); | 683 assertHasRegion(HighlightRegionType.IMPORT_PREFIX, 'ma.max'); |
730 }); | |
731 } | 684 } |
732 | 685 |
733 test_KEYWORD() { | 686 test_KEYWORD() async { |
734 addTestFile(''' | 687 addTestFile(''' |
735 main() { | 688 main() { |
736 assert(true); | 689 assert(true); |
737 for (;;) break; | 690 for (;;) break; |
738 switch (0) { | 691 switch (0) { |
739 case 0: break; | 692 case 0: break; |
740 default: break; | 693 default: break; |
741 } | 694 } |
742 try {} catch (e) {} | 695 try {} catch (e) {} |
743 const v1 = 0; | 696 const v1 = 0; |
(...skipping 12 matching lines...) Expand all Loading... |
756 } | 709 } |
757 class A {} | 710 class A {} |
758 class B extends A { | 711 class B extends A { |
759 B() : super(); | 712 B() : super(); |
760 m() { | 713 m() { |
761 return this; | 714 return this; |
762 } | 715 } |
763 } | 716 } |
764 class C = Object with A; | 717 class C = Object with A; |
765 '''); | 718 '''); |
766 return prepareHighlights().then((_) { | 719 await prepareHighlights(); |
767 assertHasRegion(HighlightRegionType.KEYWORD, 'assert(true)'); | 720 assertHasRegion(HighlightRegionType.KEYWORD, 'assert(true)'); |
768 assertHasRegion(HighlightRegionType.KEYWORD, 'for (;;)'); | 721 assertHasRegion(HighlightRegionType.KEYWORD, 'for (;;)'); |
769 assertHasRegion(HighlightRegionType.KEYWORD, 'for (var v4 in'); | 722 assertHasRegion(HighlightRegionType.KEYWORD, 'for (var v4 in'); |
770 assertHasRegion(HighlightRegionType.KEYWORD, 'break;'); | 723 assertHasRegion(HighlightRegionType.KEYWORD, 'break;'); |
771 assertHasRegion(HighlightRegionType.KEYWORD, 'case 0:'); | 724 assertHasRegion(HighlightRegionType.KEYWORD, 'case 0:'); |
772 assertHasRegion(HighlightRegionType.KEYWORD, 'catch (e) {}'); | 725 assertHasRegion(HighlightRegionType.KEYWORD, 'catch (e) {}'); |
773 assertHasRegion(HighlightRegionType.KEYWORD, 'class A {}'); | 726 assertHasRegion(HighlightRegionType.KEYWORD, 'class A {}'); |
774 assertHasRegion(HighlightRegionType.KEYWORD, 'const v1'); | 727 assertHasRegion(HighlightRegionType.KEYWORD, 'const v1'); |
775 assertHasRegion(HighlightRegionType.KEYWORD, 'continue;'); | 728 assertHasRegion(HighlightRegionType.KEYWORD, 'continue;'); |
776 assertHasRegion(HighlightRegionType.KEYWORD, 'default:'); | 729 assertHasRegion(HighlightRegionType.KEYWORD, 'default:'); |
777 assertHasRegion(HighlightRegionType.KEYWORD, 'do {} while'); | 730 assertHasRegion(HighlightRegionType.KEYWORD, 'do {} while'); |
778 assertHasRegion(HighlightRegionType.KEYWORD, 'if (true)'); | 731 assertHasRegion(HighlightRegionType.KEYWORD, 'if (true)'); |
779 assertHasRegion(HighlightRegionType.KEYWORD, 'false;'); | 732 assertHasRegion(HighlightRegionType.KEYWORD, 'false;'); |
780 assertHasRegion(HighlightRegionType.KEYWORD, 'final v3 ='); | 733 assertHasRegion(HighlightRegionType.KEYWORD, 'final v3 ='); |
781 assertHasRegion(HighlightRegionType.KEYWORD, 'finally {}'); | 734 assertHasRegion(HighlightRegionType.KEYWORD, 'finally {}'); |
782 assertHasRegion(HighlightRegionType.KEYWORD, 'in []'); | 735 assertHasRegion(HighlightRegionType.KEYWORD, 'in []'); |
783 assertHasRegion(HighlightRegionType.KEYWORD, 'is int'); | 736 assertHasRegion(HighlightRegionType.KEYWORD, 'is int'); |
784 assertHasRegion(HighlightRegionType.KEYWORD, 'new A();'); | 737 assertHasRegion(HighlightRegionType.KEYWORD, 'new A();'); |
785 assertHasRegion(HighlightRegionType.KEYWORD, 'rethrow;'); | 738 assertHasRegion(HighlightRegionType.KEYWORD, 'rethrow;'); |
786 assertHasRegion(HighlightRegionType.KEYWORD, 'return this'); | 739 assertHasRegion(HighlightRegionType.KEYWORD, 'return this'); |
787 assertHasRegion(HighlightRegionType.KEYWORD, 'super();'); | 740 assertHasRegion(HighlightRegionType.KEYWORD, 'super();'); |
788 assertHasRegion(HighlightRegionType.KEYWORD, 'switch (0)'); | 741 assertHasRegion(HighlightRegionType.KEYWORD, 'switch (0)'); |
789 assertHasRegion(HighlightRegionType.KEYWORD, 'this;'); | 742 assertHasRegion(HighlightRegionType.KEYWORD, 'this;'); |
790 assertHasRegion(HighlightRegionType.KEYWORD, 'true;'); | 743 assertHasRegion(HighlightRegionType.KEYWORD, 'true;'); |
791 assertHasRegion(HighlightRegionType.KEYWORD, 'try {'); | 744 assertHasRegion(HighlightRegionType.KEYWORD, 'try {'); |
792 assertHasRegion(HighlightRegionType.KEYWORD, 'while (true) {}'); | 745 assertHasRegion(HighlightRegionType.KEYWORD, 'while (true) {}'); |
793 assertHasRegion(HighlightRegionType.KEYWORD, 'while (true);'); | 746 assertHasRegion(HighlightRegionType.KEYWORD, 'while (true);'); |
794 assertHasRegion(HighlightRegionType.KEYWORD, 'with A;'); | 747 assertHasRegion(HighlightRegionType.KEYWORD, 'with A;'); |
795 }); | |
796 } | 748 } |
797 | 749 |
798 test_KEYWORD_void() { | 750 test_KEYWORD_void() async { |
799 addTestFile(''' | 751 addTestFile(''' |
800 void main() { | 752 void main() { |
801 } | 753 } |
802 '''); | 754 '''); |
803 return prepareHighlights().then((_) { | 755 await prepareHighlights(); |
804 assertHasRegion(HighlightRegionType.KEYWORD, 'void main()'); | 756 assertHasRegion(HighlightRegionType.KEYWORD, 'void main()'); |
805 }); | |
806 } | 757 } |
807 | 758 |
808 test_LABEL() { | 759 test_LABEL() async { |
809 addTestFile(''' | 760 addTestFile(''' |
810 main() { | 761 main() { |
811 myLabel: | 762 myLabel: |
812 while (true) { | 763 while (true) { |
813 break myLabel; | 764 break myLabel; |
814 } | 765 } |
815 } | 766 } |
816 '''); | 767 '''); |
817 return prepareHighlights().then((_) { | 768 await prepareHighlights(); |
818 assertHasRegion(HighlightRegionType.LABEL, 'myLabel:'); | 769 assertHasRegion(HighlightRegionType.LABEL, 'myLabel:'); |
819 assertHasRegion(HighlightRegionType.LABEL, 'myLabel;'); | 770 assertHasRegion(HighlightRegionType.LABEL, 'myLabel;'); |
820 }); | |
821 } | 771 } |
822 | 772 |
823 test_LITERAL_BOOLEAN() { | 773 test_LITERAL_BOOLEAN() async { |
824 addTestFile('var V = true;'); | 774 addTestFile('var V = true;'); |
825 return prepareHighlights().then((_) { | 775 await prepareHighlights(); |
826 assertHasRegion(HighlightRegionType.LITERAL_BOOLEAN, 'true;'); | 776 assertHasRegion(HighlightRegionType.LITERAL_BOOLEAN, 'true;'); |
827 }); | |
828 } | 777 } |
829 | 778 |
830 test_LITERAL_DOUBLE() { | 779 test_LITERAL_DOUBLE() async { |
831 addTestFile('var V = 4.2;'); | 780 addTestFile('var V = 4.2;'); |
832 return prepareHighlights().then((_) { | 781 await prepareHighlights(); |
833 assertHasRegion(HighlightRegionType.LITERAL_DOUBLE, '4.2;', '4.2'.length); | 782 assertHasRegion(HighlightRegionType.LITERAL_DOUBLE, '4.2;', '4.2'.length); |
834 }); | |
835 } | 783 } |
836 | 784 |
837 test_LITERAL_INTEGER() { | 785 test_LITERAL_INTEGER() async { |
838 addTestFile('var V = 42;'); | 786 addTestFile('var V = 42;'); |
839 return prepareHighlights().then((_) { | 787 await prepareHighlights(); |
840 assertHasRegion(HighlightRegionType.LITERAL_INTEGER, '42;'); | 788 assertHasRegion(HighlightRegionType.LITERAL_INTEGER, '42;'); |
841 }); | |
842 } | 789 } |
843 | 790 |
844 test_LITERAL_LIST() { | 791 test_LITERAL_LIST() async { |
845 addTestFile('var V = <int>[1, 2, 3];'); | 792 addTestFile('var V = <int>[1, 2, 3];'); |
846 return prepareHighlights().then((_) { | 793 await prepareHighlights(); |
847 assertHasStringRegion(HighlightRegionType.LITERAL_LIST, '<int>[1, 2, 3]'); | 794 assertHasStringRegion(HighlightRegionType.LITERAL_LIST, '<int>[1, 2, 3]'); |
848 }); | |
849 } | 795 } |
850 | 796 |
851 test_LITERAL_MAP() { | 797 test_LITERAL_MAP() async { |
852 addTestFile("var V = const <int, String>{1: 'a', 2: 'b', 3: 'c'};"); | 798 addTestFile("var V = const <int, String>{1: 'a', 2: 'b', 3: 'c'};"); |
853 return prepareHighlights().then((_) { | 799 await prepareHighlights(); |
854 assertHasStringRegion(HighlightRegionType.LITERAL_MAP, | 800 assertHasStringRegion(HighlightRegionType.LITERAL_MAP, |
855 "const <int, String>{1: 'a', 2: 'b', 3: 'c'}"); | 801 "const <int, String>{1: 'a', 2: 'b', 3: 'c'}"); |
856 }); | |
857 } | 802 } |
858 | 803 |
859 test_LITERAL_STRING() { | 804 test_LITERAL_STRING() async { |
860 addTestFile('var V = "abc";'); | 805 addTestFile('var V = "abc";'); |
861 return prepareHighlights().then((_) { | 806 await prepareHighlights(); |
862 assertHasRegion( | 807 assertHasRegion( |
863 HighlightRegionType.LITERAL_STRING, '"abc";', '"abc"'.length); | 808 HighlightRegionType.LITERAL_STRING, '"abc";', '"abc"'.length); |
864 }); | |
865 } | 809 } |
866 | 810 |
867 test_LOCAL_VARIABLE() { | 811 test_LOCAL_VARIABLE() async { |
868 addTestFile(''' | 812 addTestFile(''' |
869 main() { | 813 main() { |
870 int vvv = 0; | 814 int vvv = 0; |
871 vvv; | 815 vvv; |
872 vvv = 1; | 816 vvv = 1; |
873 } | 817 } |
874 '''); | 818 '''); |
875 return prepareHighlights().then((_) { | 819 await prepareHighlights(); |
876 assertHasRegion( | 820 assertHasRegion(HighlightRegionType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0'); |
877 HighlightRegionType.LOCAL_VARIABLE_DECLARATION, 'vvv = 0'); | 821 assertHasRegion(HighlightRegionType.LOCAL_VARIABLE, 'vvv;'); |
878 assertHasRegion(HighlightRegionType.LOCAL_VARIABLE, 'vvv;'); | 822 assertHasRegion(HighlightRegionType.LOCAL_VARIABLE, 'vvv = 1;'); |
879 assertHasRegion(HighlightRegionType.LOCAL_VARIABLE, 'vvv = 1;'); | |
880 }); | |
881 } | 823 } |
882 | 824 |
883 test_METHOD() { | 825 test_METHOD() async { |
884 addTestFile(''' | 826 addTestFile(''' |
885 class A { | 827 class A { |
886 aaa() {} | 828 aaa() {} |
887 static bbb() {} | 829 static bbb() {} |
888 } | 830 } |
889 main(A a) { | 831 main(A a) { |
890 a.aaa(); | 832 a.aaa(); |
891 a.aaa; | 833 a.aaa; |
892 A.bbb(); | 834 A.bbb(); |
893 A.bbb; | 835 A.bbb; |
894 } | 836 } |
895 '''); | 837 '''); |
896 return prepareHighlights().then((_) { | 838 await prepareHighlights(); |
897 assertHasRegion(HighlightRegionType.METHOD_DECLARATION, 'aaa() {}'); | 839 assertHasRegion(HighlightRegionType.METHOD_DECLARATION, 'aaa() {}'); |
898 assertHasRegion( | 840 assertHasRegion(HighlightRegionType.METHOD_DECLARATION_STATIC, 'bbb() {}'); |
899 HighlightRegionType.METHOD_DECLARATION_STATIC, 'bbb() {}'); | 841 assertHasRegion(HighlightRegionType.METHOD, 'aaa();'); |
900 assertHasRegion(HighlightRegionType.METHOD, 'aaa();'); | 842 assertHasRegion(HighlightRegionType.METHOD, 'aaa;'); |
901 assertHasRegion(HighlightRegionType.METHOD, 'aaa;'); | 843 assertHasRegion(HighlightRegionType.METHOD_STATIC, 'bbb();'); |
902 assertHasRegion(HighlightRegionType.METHOD_STATIC, 'bbb();'); | 844 assertHasRegion(HighlightRegionType.METHOD_STATIC, 'bbb;'); |
903 assertHasRegion(HighlightRegionType.METHOD_STATIC, 'bbb;'); | |
904 }); | |
905 } | 845 } |
906 | 846 |
907 test_METHOD_bestType() { | 847 test_METHOD_bestType() async { |
908 addTestFile(''' | 848 addTestFile(''' |
909 main(p) { | 849 main(p) { |
910 if (p is List) { | 850 if (p is List) { |
911 p.add(null); | 851 p.add(null); |
912 } | 852 } |
913 } | 853 } |
914 '''); | 854 '''); |
915 return prepareHighlights().then((_) { | 855 await prepareHighlights(); |
916 assertHasRegion(HighlightRegionType.METHOD, 'add(null)'); | 856 assertHasRegion(HighlightRegionType.METHOD, 'add(null)'); |
917 }); | |
918 } | 857 } |
919 | 858 |
920 test_PARAMETER() { | 859 test_PARAMETER() async { |
921 addTestFile(''' | 860 addTestFile(''' |
922 main(int p) { | 861 main(int p) { |
923 p; | 862 p; |
924 p = 42; | 863 p = 42; |
925 } | 864 } |
926 '''); | 865 '''); |
927 return prepareHighlights().then((_) { | 866 await prepareHighlights(); |
928 assertHasRegion(HighlightRegionType.PARAMETER, 'p) {'); | 867 assertHasRegion(HighlightRegionType.PARAMETER, 'p) {'); |
929 assertHasRegion(HighlightRegionType.PARAMETER, 'p;'); | 868 assertHasRegion(HighlightRegionType.PARAMETER, 'p;'); |
930 assertHasRegion(HighlightRegionType.PARAMETER, 'p = 42'); | 869 assertHasRegion(HighlightRegionType.PARAMETER, 'p = 42'); |
931 }); | |
932 } | 870 } |
933 | 871 |
934 test_SETTER_DECLARATION() { | 872 test_SETTER_DECLARATION() async { |
935 addTestFile(''' | 873 addTestFile(''' |
936 set aaa(x) {} | 874 set aaa(x) {} |
937 class A { | 875 class A { |
938 set bbb(x) {} | 876 set bbb(x) {} |
939 } | 877 } |
940 main(A a) { | 878 main(A a) { |
941 aaa = 1; | 879 aaa = 1; |
942 a.bbb = 2; | 880 a.bbb = 2; |
943 } | 881 } |
944 '''); | 882 '''); |
945 return prepareHighlights().then((_) { | 883 await prepareHighlights(); |
946 assertHasRegion(HighlightRegionType.SETTER_DECLARATION, 'aaa(x)'); | 884 assertHasRegion(HighlightRegionType.SETTER_DECLARATION, 'aaa(x)'); |
947 assertHasRegion(HighlightRegionType.SETTER_DECLARATION, 'bbb(x)'); | 885 assertHasRegion(HighlightRegionType.SETTER_DECLARATION, 'bbb(x)'); |
948 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'aaa = 1'); | 886 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'aaa = 1'); |
949 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 2'); | 887 assertHasRegion(HighlightRegionType.FIELD, 'bbb = 2'); |
950 }); | |
951 } | 888 } |
952 | 889 |
953 test_TOP_LEVEL_VARIABLE() { | 890 test_TOP_LEVEL_VARIABLE() async { |
954 addTestFile(''' | 891 addTestFile(''' |
955 const VVV = 0; | 892 const VVV = 0; |
956 @VVV // annotation | 893 @VVV // annotation |
957 main() { | 894 main() { |
958 print(VVV); | 895 print(VVV); |
959 VVV = 1; | 896 VVV = 1; |
960 } | 897 } |
961 '''); | 898 '''); |
962 return prepareHighlights().then((_) { | 899 await prepareHighlights(); |
963 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV = 0'); | 900 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV = 0'); |
964 assertHasRegion( | 901 assertHasRegion( |
965 HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV // annotation'); | 902 HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV // annotation'); |
966 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV);'); | 903 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV);'); |
967 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV = 1'); | 904 assertHasRegion(HighlightRegionType.TOP_LEVEL_VARIABLE, 'VVV = 1'); |
968 }); | |
969 } | 905 } |
970 | 906 |
971 test_TYPE_NAME_DYNAMIC() { | 907 test_TYPE_NAME_DYNAMIC() async { |
972 addTestFile(''' | 908 addTestFile(''' |
973 dynamic main() { | 909 dynamic main() { |
974 dynamic = 42; | 910 dynamic = 42; |
975 } | 911 } |
976 '''); | 912 '''); |
977 return prepareHighlights().then((_) { | 913 await prepareHighlights(); |
978 assertHasRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic main()'); | 914 assertHasRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic main()'); |
979 assertNoRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'dynamic main()'); | 915 assertNoRegion(HighlightRegionType.IDENTIFIER_DEFAULT, 'dynamic main()'); |
980 assertNoRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic = 42'); | 916 assertNoRegion(HighlightRegionType.TYPE_NAME_DYNAMIC, 'dynamic = 42'); |
981 }); | |
982 } | 917 } |
983 | 918 |
984 test_TYPE_PARAMETER() { | 919 test_TYPE_PARAMETER() async { |
985 addTestFile(''' | 920 addTestFile(''' |
986 class A<T> { | 921 class A<T> { |
987 T fff; | 922 T fff; |
988 T mmm(T p) => null; | 923 T mmm(T p) => null; |
989 } | 924 } |
990 '''); | 925 '''); |
991 return prepareHighlights().then((_) { | 926 await prepareHighlights(); |
992 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T> {'); | 927 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T> {'); |
993 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T fff;'); | 928 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T fff;'); |
994 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T mmm('); | 929 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T mmm('); |
995 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T p)'); | 930 assertHasRegion(HighlightRegionType.TYPE_PARAMETER, 'T p)'); |
996 }); | |
997 } | 931 } |
998 | 932 |
999 void _addLibraryForTestPart() { | 933 void _addLibraryForTestPart() { |
1000 addFile( | 934 addFile( |
1001 '$testFolder/my_lib.dart', | 935 '$testFolder/my_lib.dart', |
1002 ''' | 936 ''' |
1003 library lib; | 937 library lib; |
1004 part 'test.dart'; | 938 part 'test.dart'; |
1005 '''); | 939 '''); |
1006 } | 940 } |
1007 } | 941 } |
1008 | 942 |
1009 @reflectiveTest | 943 @reflectiveTest |
1010 class HighlightTypeTest { | 944 class HighlightTypeTest { |
1011 void test_constructor() { | 945 void test_constructor() { |
1012 expect(HighlightRegionType.CLASS, | 946 expect(HighlightRegionType.CLASS, |
1013 new HighlightRegionType(HighlightRegionType.CLASS.name)); | 947 new HighlightRegionType(HighlightRegionType.CLASS.name)); |
1014 } | 948 } |
1015 | 949 |
1016 void test_toString() { | 950 void test_toString() { |
1017 expect(HighlightRegionType.CLASS.toString(), 'HighlightRegionType.CLASS'); | 951 expect(HighlightRegionType.CLASS.toString(), 'HighlightRegionType.CLASS'); |
1018 } | 952 } |
1019 | 953 |
1020 void test_valueOf_unknown() { | 954 void test_valueOf_unknown() { |
1021 expect(() { | 955 expect(() { |
1022 new HighlightRegionType('no-such-type'); | 956 new HighlightRegionType('no-such-type'); |
1023 }, throws); | 957 }, throws); |
1024 } | 958 } |
1025 } | 959 } |
OLD | NEW |