Reformat

pkg/analysis_server/test/services/correction/assist_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.services.correction.assist;
 
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/correction/assist.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../abstract_single_unit.dart';
 import '../../reflective_tests.dart';
 
-
 main() {
   groupSep = ' | ';
   runReflectiveTests(AssistProcessorTest);
 }
 
-
 @reflectiveTest
 class AssistProcessorTest extends AbstractSingleUnitTest {
   int offset;
   int length;
 
   Assist assist;
   SourceChange change;
   String resultCode;
   LinkedEditGroup linkedPositionGroup;
 
   /**
    * Asserts that there is an [Assist] of the given [kind] at [offset] which
    * produces the [expected] code when applied to [testCode].
    */
   void assertHasAssist(AssistKind kind, String expected) {
     assist = _assertHasAssist(kind);
     change = assist.change;
     // apply to "file"
     List<SourceFileEdit> fileEdits = change.edits;
     expect(fileEdits, hasLength(1));
     resultCode = SourceEdit.applySequence(testCode, change.edits[0].edits);
     // verify
     expect(resultCode, expected);
   }
 
   /**
    * Calls [assertHasAssist] at the offset of [offsetSearch] in [testCode].
    */
-  void assertHasAssistAt(String offsetSearch, AssistKind kind,
-      String expected) {
+  void assertHasAssistAt(
+      String offsetSearch, AssistKind kind, String expected) {
     offset = findOffset(offsetSearch);
     assertHasAssist(kind, expected);
   }
 
   /**
    * Asserts that there is no [Assist] of the given [kind] at [offset].
    */
   void assertNoAssist(AssistKind kind) {
     List<Assist> assists = computeAssists(testUnit, offset, length);
     for (Assist assist in assists) {
@@ skipping 17 matching lines @@
   }
 
   List<Position> expectedPositions(List<String> patterns) {
     List<Position> positions = <Position>[];
     patterns.forEach((String search) {
       positions.add(expectedPosition(search));
     });
     return positions;
   }
 
-  List<LinkedEditSuggestion> expectedSuggestions(LinkedEditSuggestionKind kind,
-      List<String> values) {
+  List<LinkedEditSuggestion> expectedSuggestions(
+      LinkedEditSuggestionKind kind, List<String> values) {
     return values.map((value) {
       return new LinkedEditSuggestion(value, kind);
     }).toList();
   }
 
   void setUp() {
     super.setUp();
     offset = 0;
     length = 0;
   }
@@ skipping 487 matching lines @@
 }
 List<int> readBytes() => <int>[];
 ''');
     assertHasAssistAt('readBytes();', AssistKind.ASSIGN_TO_LOCAL_VARIABLE, '''
 main() {
   List<int> bytes;
   var readBytes = readBytes();
 }
 List<int> readBytes() => <int>[];
 ''');
-    _assertLinkedGroup(
-        change.linkedEditGroups[0],
-        ['readBytes = '],
-        expectedSuggestions(
-            LinkedEditSuggestionKind.VARIABLE,
-            ['list', 'bytes2', 'readBytes']));
+    _assertLinkedGroup(change.linkedEditGroups[0], [
+      'readBytes = '
+    ], expectedSuggestions(
+        LinkedEditSuggestionKind.VARIABLE, ['list', 'bytes2', 'readBytes']));
   }
 
   void test_assignToLocalVariable_alreadyAssignment() {
     resolveTestUnit('''
 main() {
   var vvv;
   vvv = 42;
 }
 ''');
     assertNoAssistAt('vvv =', AssistKind.ASSIGN_TO_LOCAL_VARIABLE);
@@ skipping 168 matching lines @@
   }
 
   void test_convertToExpressionBody_OK_method_onBlock() {
     resolveTestUnit('''
 class A {
   m() { // marker
     return 42;
   }
 }
 ''');
-    assertHasAssistAt(
-        '{ // marker',
-        AssistKind.CONVERT_INTO_EXPRESSION_BODY,
+    assertHasAssistAt('{ // marker', AssistKind.CONVERT_INTO_EXPRESSION_BODY,
         '''
 class A {
   m() => 42;
 }
 ''');
   }
 
   void test_convertToExpressionBody_OK_topFunction_onReturnStatement() {
     resolveTestUnit('''
 fff() {
@@ skipping 330 matching lines @@
   1 + 2 - 3 + 4;
 }
 ''');
     assertHasAssistAt('+ 2', AssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 1 - 3 + 4;
 }
 ''');
   }
 
-  void
-      test_exchangeBinaryExpressionArguments_OK_extended_sameOperator_afterFirst() {
+  void test_exchangeBinaryExpressionArguments_OK_extended_sameOperator_afterFirst() {
     resolveTestUnit('''
 main() {
   1 + 2 + 3;
 }
 ''');
     assertHasAssistAt('+ 2', AssistKind.EXCHANGE_OPERANDS, '''
 main() {
   2 + 3 + 1;
 }
 ''');
   }
 
-  void
-      test_exchangeBinaryExpressionArguments_OK_extended_sameOperator_afterSecond() {
+  void test_exchangeBinaryExpressionArguments_OK_extended_sameOperator_afterSecond() {
     resolveTestUnit('''
 main() {
   1 + 2 + 3;
 }
 ''');
     assertHasAssistAt('+ 3', AssistKind.EXCHANGE_OPERANDS, '''
 main() {
   3 + 1 + 2;
 }
 ''');
@@ skipping 194 matching lines @@
     String expected = '''
 class MyTypeName {}
 main(p) {
   if (p is MyTypeName) {
     MyTypeName myTypeName = p;
   }
   p = null;
 }
 ''';
     assertHasAssistAt(
-        'is MyType',
-        AssistKind.INTRODUCE_LOCAL_CAST_TYPE,
-        expected);
-    _assertLinkedGroup(
-        change.linkedEditGroups[0],
-        ['myTypeName = '],
-        expectedSuggestions(
-            LinkedEditSuggestionKind.VARIABLE,
-            ['myTypeName', 'typeName', 'name']));
+        'is MyType', AssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
+    _assertLinkedGroup(change.linkedEditGroups[0], [
+      'myTypeName = '
+    ], expectedSuggestions(
+        LinkedEditSuggestionKind.VARIABLE, ['myTypeName', 'typeName', 'name']));
     // another good location
     assertHasAssistAt('if (p', AssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
   }
 
   void test_introduceLocalTestedType_OK_while() {
     resolveTestUnit('''
 main(p) {
   while (p is String) {
   }
   p = null;
 }
 ''');
     String expected = '''
 main(p) {
   while (p is String) {
     String s = p;
   }
   p = null;
 }
 ''';
     assertHasAssistAt(
-        'is String',
-        AssistKind.INTRODUCE_LOCAL_CAST_TYPE,
-        expected);
+        'is String', AssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
     assertHasAssistAt(
-        'while (p',
-        AssistKind.INTRODUCE_LOCAL_CAST_TYPE,
-        expected);
+        'while (p', AssistKind.INTRODUCE_LOCAL_CAST_TYPE, expected);
   }
 
   void test_invalidSelection() {
     resolveTestUnit('');
     List<Assist> assists = computeAssists(testUnit, -1, 0);
     expect(assists, isEmpty);
   }
 
   void test_invertIfStatement_blocks() {
     resolveTestUnit('''
@@ skipping 599 matching lines @@
   void test_joinVariableDeclaration_onDeclaration_wrong_lastStatement() {
     resolveTestUnit('''
 main() {
   if (true)
     var v;
 }
 ''');
     assertNoAssistAt('v;', AssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
-  void
-      test_joinVariableDeclaration_onDeclaration_wrong_nextNotAssignmentExpression() {
+  void test_joinVariableDeclaration_onDeclaration_wrong_nextNotAssignmentExpression() {
     resolveTestUnit('''
 main() {
   var v;
   42;
 }
 ''');
     assertNoAssistAt('v;', AssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
-  void
-      test_joinVariableDeclaration_onDeclaration_wrong_nextNotExpressionStatement() {
+  void test_joinVariableDeclaration_onDeclaration_wrong_nextNotExpressionStatement() {
     resolveTestUnit('''
 main() {
   var v;
   if (true) return;
 }
 ''');
     assertNoAssistAt('v;', AssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
-  void
-      test_joinVariableDeclaration_onDeclaration_wrong_nextNotPureAssignment() {
+  void test_joinVariableDeclaration_onDeclaration_wrong_nextNotPureAssignment() {
     resolveTestUnit('''
 main() {
   var v;
   v += 1;
 }
 ''');
     assertNoAssistAt('v;', AssistKind.JOIN_VARIABLE_DECLARATION);
   }
 
   void test_joinVariableDeclaration_onDeclaration_wrong_notOneVariable() {
@@ skipping 71 matching lines @@
 }
 ''');
   }
 
   void test_replaceConditionalWithIfElse_OK_return() {
     resolveTestUnit('''
 main() {
   return true ? 111 : 222;
 }
 ''');
-    assertHasAssistAt(
-        'return ',
-        AssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
+    assertHasAssistAt('return ', AssistKind.REPLACE_CONDITIONAL_WITH_IF_ELSE,
         '''
 main() {
   if (true) {
     return 111;
   } else {
     return 222;
   }
 }
 ''');
   }
@@ skipping 36 matching lines @@
     resolveTestUnit('''
 main() {
   int vvv;
   if (true) {
     vvv = 111;
   } else {
     vvv = 222;
   }
 }
 ''');
-    assertHasAssistAt(
-        'if (true)',
-        AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
+    assertHasAssistAt('if (true)', AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
         '''
 main() {
   int vvv;
   vvv = true ? 111 : 222;
 }
 ''');
   }
 
   void test_replaceIfElseWithConditional_OK_return() {
     resolveTestUnit('''
 main() {
   if (true) {
     return 111;
   } else {
     return 222;
   }
 }
 ''');
-    assertHasAssistAt(
-        'if (true)',
-        AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
+    assertHasAssistAt('if (true)', AssistKind.REPLACE_IF_ELSE_WITH_CONDITIONAL,
         '''
 main() {
   return true ? 111 : 222;
 }
 ''');
   }
 
   void test_replaceIfElseWithConditional_wrong_expressionVsReturn() {
     resolveTestUnit('''
 main() {
@@ skipping 418 matching lines @@
       positions.add(new Position(testFile, offset));
     }
     return positions;
   }
 
   void _setStartEndSelection() {
     offset = findOffset('// start\n') + '// start\n'.length;
     length = findOffset('// end') - offset;
   }
 }