Format analyzer, analysis_server, analyzer_plugin, front_end and kernel with the latest dartfmt.

pkg/analysis_server/test/services/completion/postfix/postfix_completion_test.dart

 // Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/completion/postfix/postfix_completion.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ skipping 70 matching lines @@
   _prepareCompletionAt(int offset, String key, String sourceCode) async {
     verifyNoTestUnitErrors = false;
     await resolveTestUnit(sourceCode);
     await _computeCompletion(offset, key);
   }
 }
 
 @reflectiveTest
 class _AssertTest extends PostfixCompletionTest {
   test_assert() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f(bool expr) {
   expr.assert
 }
 ''');
-    _assertHasChange(
-        'Expand .assert',
-        '''
+    _assertHasChange('Expand .assert', '''
 f(bool expr) {
   assert(expr);
 }
 ''');
   }
 
   test_assertFunc() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f() {
   () => true.assert
 }
 ''');
-    _assertHasChange(
-        'Expand .assert',
-        '''
+    _assertHasChange('Expand .assert', '''
 f() {
   assert(() => true);
 }
 ''');
   }
 
   @failingTest
   test_assertFunc_invalid() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f() {
   () => null.assert
 }
 ''');
   }
 
   test_assertFuncCmp() async {
-    await _prepareCompletion(
-        '.assert',
-        '''
+    await _prepareCompletion('.assert', '''
 f(int x, int y) {
   () => x + 3 > y + 4.assert
 }
 ''');
-    _assertHasChange(
-        'Expand .assert',
-        '''
+    _assertHasChange('Expand .assert', '''
 f(int x, int y) {
   assert(() => x + 3 > y + 4);
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _ForTest extends PostfixCompletionTest {
   @failingTest
   test_for_invalid() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   {}.for
 }
 ''');
   }
 
   test_forEmptyDynamic() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   [].for
 }
 ''');
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 f() {
   for (var value in []) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_forEmptyString() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   <String>[].for
 }
 ''');
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 f() {
   for (var value in <String>[]) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_fori() async {
-    await _prepareCompletion(
-        '.fori',
-        '''
+    await _prepareCompletion('.fori', '''
 f() {
   100.fori
 }
 ''');
-    _assertHasChange(
-        'Expand .fori',
-        '''
+    _assertHasChange('Expand .fori', '''
 f() {
   for (int i = 0; i < 100; i++) {
     /*caret*/
   }
 }
 ''');
   }
 
   @failingTest
   test_fori_invalid() async {
-    await _prepareCompletion(
-        '.fori',
-        '''
+    await _prepareCompletion('.fori', '''
 f() {
   [].fori
 }
 ''');
   }
 
   test_forIntList() async {
-    await _prepareCompletion(
-        '.for',
-        '''
+    await _prepareCompletion('.for', '''
 f() {
   [1,2,3].for
 }
 ''');
-    _assertHasChange(
-        'Expand .for',
-        '''
+    _assertHasChange('Expand .for', '''
 f() {
   for (var value in [1,2,3]) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_foriVar() async {
-    await _prepareCompletion(
-        '.fori',
-        '''
+    await _prepareCompletion('.fori', '''
 f() {
   var n = 100;
   n.fori
 }
 ''');
-    _assertHasChange(
-        'Expand .fori',
-        '''
+    _assertHasChange('Expand .fori', '''
 f() {
   var n = 100;
   for (int i = 0; i < n; i++) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_iterList() async {
-    await _prepareCompletion(
-        '.iter',
-        '''
+    await _prepareCompletion('.iter', '''
 f() {
   [1,2,3].iter
 }
 ''');
-    _assertHasChange(
-        'Expand .iter',
-        '''
+    _assertHasChange('Expand .iter', '''
 f() {
   for (var value in [1,2,3]) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_iterName() async {
-    await _prepareCompletion(
-        '.iter',
-        '''
+    await _prepareCompletion('.iter', '''
 f() {
   var value = [1,2,3];
   value.iter
 }
 ''');
-    _assertHasChange(
-        'Expand .iter',
-        '''
+    _assertHasChange('Expand .iter', '''
 f() {
   var value = [1,2,3];
   for (var value1 in value) {
     /*caret*/
   }
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _IfTest extends PostfixCompletionTest {
   test_Else() async {
-    await _prepareCompletion(
-        '.else',
-        '''
+    await _prepareCompletion('.else', '''
 f(bool val) {
   val.else
 }
 ''');
-    _assertHasChange(
-        'Expand .else',
-        '''
+    _assertHasChange('Expand .else', '''
 f(bool val) {
   if (!val) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_if() async {
-    await _prepareCompletion(
-        '.if',
-        '''
+    await _prepareCompletion('.if', '''
 f() {
   3 < 4.if
 }
 ''');
-    _assertHasChange(
-        'Expand .if',
-        '''
+    _assertHasChange('Expand .if', '''
 f() {
   if (3 < 4) {
     /*caret*/
   }
 }
 ''');
   }
 
   @failingTest
   test_if_invalid() async {
-    await _prepareCompletion(
-        '.if',
-        '''
+    await _prepareCompletion('.if', '''
 f(List expr) {
   expr.if
 }
 ''');
   }
 
   test_ifDynamic() async {
-    await _prepareCompletion(
-        '.if',
-        '''
+    await _prepareCompletion('.if', '''
 f(expr) {
   expr.if
 }
 ''');
-    _assertHasChange(
-        'Expand .if',
-        '''
+    _assertHasChange('Expand .if', '''
 f(expr) {
   if (expr) {
     /*caret*/
   }
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _NegateTest extends PostfixCompletionTest {
   test_negate() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(expr) {
   if (expr.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(expr) {
   if (!expr)
 }
 ''');
   }
 
   @failingTest
   test_negate_invalid() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(int expr) {
   if (expr.not)
 }
 ''');
   }
 
   test_negateCascade() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(expr) {
   if (expr..a..b..c.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(expr) {
   if (!expr..a..b..c)
 }
 ''');
   }
 
   test_negateExpr() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(int i, int j) {
   if (i + 3 < j - 4.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(int i, int j) {
   if (i + 3 >= j - 4)
 }
 ''');
   }
 
   test_negateProperty() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f(expr) {
   if (expr.a.b.c.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f(expr) {
   if (!expr.a.b.c)
 }
 ''');
   }
 
   test_notFalse() async {
-    await _prepareCompletion(
-        '!',
-        '''
+    await _prepareCompletion('!', '''
 f() {
   if (false!)
 }
 ''');
-    _assertHasChange(
-        'Expand !',
-        '''
+    _assertHasChange('Expand !', '''
 f() {
   if (true)
 }
 ''');
   }
 
   test_notFunc() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 bool f() {
   if (f().not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 bool f() {
   if (!f())
 }
 ''');
   }
 
   test_notTrue() async {
-    await _prepareCompletion(
-        '.not',
-        '''
+    await _prepareCompletion('.not', '''
 f() {
   if (true.not)
 }
 ''');
-    _assertHasChange(
-        'Expand .not',
-        '''
+    _assertHasChange('Expand .not', '''
 f() {
   if (false)
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _NotNullTest extends PostfixCompletionTest {
   test_nn() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f(expr) {
   var list = [1,2,3];
   list.nn
 }
 ''');
-    _assertHasChange(
-        'Expand .nn',
-        '''
+    _assertHasChange('Expand .nn', '''
 f(expr) {
   var list = [1,2,3];
   if (list != null) {
     /*caret*/
   }
 }
 ''');
   }
 
   @failingTest
   test_nn_invalid() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f(expr) {
   var list = [1,2,3];
 }.nn
 ''');
   }
 
   test_nnDynamic() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f(expr) {
   expr.nn
 }
 ''');
-    _assertHasChange(
-        'Expand .nn',
-        '''
+    _assertHasChange('Expand .nn', '''
 f(expr) {
   if (expr != null) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_notnull() async {
-    await _prepareCompletion(
-        '.notnull',
-        '''
+    await _prepareCompletion('.notnull', '''
 f(expr) {
   var list = [1,2,3];
   list.notnull
 }
 ''');
-    _assertHasChange(
-        'Expand .notnull',
-        '''
+    _assertHasChange('Expand .notnull', '''
 f(expr) {
   var list = [1,2,3];
   if (list != null) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_null() async {
-    await _prepareCompletion(
-        '.null',
-        '''
+    await _prepareCompletion('.null', '''
 f(expr) {
   var list = [1,2,3];
   list.null
 }
 ''');
-    _assertHasChange(
-        'Expand .null',
-        '''
+    _assertHasChange('Expand .null', '''
 f(expr) {
   var list = [1,2,3];
   if (list == null) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_nullnn() async {
-    await _prepareCompletion(
-        '.nn',
-        '''
+    await _prepareCompletion('.nn', '''
 f() {
   null.nn
 }
 ''');
-    _assertHasChange(
-        'Expand .nn',
-        '''
+    _assertHasChange('Expand .nn', '''
 f() {
   if (false) {
     /*caret*/
   }
 }
 ''');
   }
 
   test_nullnull() async {
-    await _prepareCompletion(
-        '.null',
-        '''
+    await _prepareCompletion('.null', '''
 f() {
   null.null
 }
 ''');
-    _assertHasChange(
-        'Expand .null',
-        '''
+    _assertHasChange('Expand .null', '''
 f() {
   if (true) {
     /*caret*/
   }
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _ParenTest extends PostfixCompletionTest {
   test_paren() async {
-    await _prepareCompletion(
-        '.par',
-        '''
+    await _prepareCompletion('.par', '''
 f(expr) {
   expr.par
 }
 ''');
-    _assertHasChange(
-        'Expand .par',
-        '''
+    _assertHasChange('Expand .par', '''
 f(expr) {
   (expr)
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _ReturnTest extends PostfixCompletionTest {
   test_return() async {
-    await _prepareCompletion(
-        '.return',
-        '''
+    await _prepareCompletion('.return', '''
 f(expr) {
   expr.return
 }
 ''');
-    _assertHasChange(
-        'Expand .return',
-        '''
+    _assertHasChange('Expand .return', '''
 f(expr) {
   return expr;
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _SwitchTest extends PostfixCompletionTest {
   test_return() async {
-    await _prepareCompletion(
-        '.switch',
-        '''
+    await _prepareCompletion('.switch', '''
 f(expr) {
   expr.switch
 }
 ''');
-    _assertHasChange(
-        'Expand .switch',
-        '''
+    _assertHasChange('Expand .switch', '''
 f(expr) {
   switch (expr) {
     /*caret*/
   }
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _TryTest extends PostfixCompletionTest {
   test_try() async {
-    await _prepareCompletion(
-        '.try',
-        '''
+    await _prepareCompletion('.try', '''
 f() {
   var x = 1.try
 }
 ''');
-    _assertHasChange(
-        'Expand .try',
-        '''
+    _assertHasChange('Expand .try', '''
 f() {
   try {
     var x = 1/*caret*/
   } catch (e, s) {
     print(s);
   }
 }
 ''');
   }
 
   @failingTest
   test_try_invalid() async {
     // The semicolon is fine; this fails because of the do-statement.
-    await _prepareCompletion(
-        '.try',
-        '''
+    await _prepareCompletion('.try', '''
 f() {
   do {} while (true);.try
 }
 ''');
   }
 
   test_tryMultiline() async {
-    await _prepareCompletion(
-        '.try',
-        '''
+    await _prepareCompletion('.try', '''
 f(arg) {
   arg
     ..first
     ..second
     ..third
     ..fourth.try
 }
 ''');
-    _assertHasChange(
-        'Expand .try',
-        '''
+    _assertHasChange('Expand .try', '''
 f(arg) {
   try {
     arg
       ..first
       ..second
       ..third
       ..fourth/*caret*/
   } catch (e, s) {
     print(s);
   }
 }
 ''');
   }
 
   test_tryon() async {
-    await _prepareCompletion(
-        '.tryon',
-        '''
+    await _prepareCompletion('.tryon', '''
 f() {
   var x = 1.tryon
 }
 ''');
-    _assertHasChange(
-        'Expand .tryon',
-        '''
+    _assertHasChange('Expand .tryon', '''
 f() {
   try {
     var x = 1/*caret*/
   } on Exception catch (e, s) {
     print(s);
   }
 }
 ''');
   }
 
   test_tryonThrowStatement() async {
-    await _prepareCompletion(
-        '.tryon',
-        '''
+    await _prepareCompletion('.tryon', '''
 f() {
   throw 'error';.tryon
 }
 ''');
-    _assertHasChange(
-        'Expand .tryon',
-        '''
+    _assertHasChange('Expand .tryon', '''
 f() {
   try {
     throw 'error';/*caret*/
   } on String catch (e, s) {
     print(s);
   }
 }
 ''');
   }
 
   test_tryonThrowString() async {
-    await _prepareCompletion(
-        '.tryon',
-        '''
+    await _prepareCompletion('.tryon', '''
 f() {
   throw 'error'.tryon
 }
 ''');
-    _assertHasChange(
-        'Expand .tryon',
-        '''
+    _assertHasChange('Expand .tryon', '''
 f() {
   try {
     throw 'error'/*caret*/
   } on String catch (e, s) {
     print(s);
   }
 }
 ''');
   }
 }
 
 @reflectiveTest
 class _WhileTest extends PostfixCompletionTest {
   test_while() async {
-    await _prepareCompletion(
-        '.while',
-        '''
+    await _prepareCompletion('.while', '''
 f(expr) {
   expr.while
 }
 ''');
-    _assertHasChange(
-        'Expand .while',
-        '''
+    _assertHasChange('Expand .while', '''
 f(expr) {
   while (expr) {
     /*caret*/
   }
 }
 ''');
   }
 }