Add completion for do-stmt, refactor for reuse

pkg/analysis_server/test/services/completion/statement/statement_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.
 
 library test.services.completion.statement;
 
 import 'package:analysis_server/src/protocol_server.dart';
 import 'package:analysis_server/src/services/completion/statement/statement_completion.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../../abstract_single_unit.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(StatementCompletionTest);
   });
 }
 
 @reflectiveTest
 class StatementCompletionTest extends AbstractSingleUnitTest {
   SourceChange change;
 
   bool get enableNewAnalysisDriver => true;
 
-  test_completeIfEmptyCondition() async {
+  test_completeDoEmptyCondition() async {
     await _prepareCompletion(
-        'if ()',
+        'while ()',
         '''
 main() {
-  if ()
+  do {
+  } while ()
 }
 ''',
         atEnd: true);
     _assertHasChange(
-        'Complete if-statement',
+        'Complete do-statement',
         '''
 main() {
-  if () {
-    ////
-  }
+  do {
+  } while ();
 }
 ''',
-        (s) => s.indexOf('if (') + 'if ('.length);
+        (s) => s.indexOf('while (') + 'while ('.length);
   }
 
-  test_completeIfKeywordOnly() async {
+  test_completeDoKeywordOnly() async {
     await _prepareCompletion(
-        'if',
+        'do',
         '''
 main() {
-  if ////
+  do ////
 }
 ''',
         atEnd: true);
     _assertHasChange(
-        'Complete if-statement',
+        'Complete do-statement',
         '''
 main() {
-  if () {
+  do {
     ////
-  }
+  } while ();
 }
 ''',
-        (s) => s.indexOf('if (') + 'if ('.length);
+        (s) => s.indexOf('while (') + 'while ('.length);
   }
 
-  test_completeIfWithCondition() async {
+  test_completeDoNoBody() async {
     await _prepareCompletion(
-        'if (tr', // Trigger completion from within expression.
+        'do',
         '''
 main() {
-  if (true)
+  do;
+  while
 }
 ''',
         atEnd: true);
     _assertHasChange(
-        'Complete if-statement',
+        'Complete do-statement',
         '''
 main() {
-  if (true) {
+  do {
     ////
+  } while ();
+}
+''',
+        (s) => s.indexOf('while (') + 'while ('.length);
+  }
+
+  test_completeDoNoCondition() async {
+    await _prepareCompletion(
+        'while',
+        '''
+main() {
+  do {
+  } while
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete do-statement',
+        '''
+main() {
+  do {
+  } while ();
+}
+''',
+        (s) => s.indexOf('while (') + 'while ('.length);
+  }
+
+  test_completeDoNoWhile() async {
+    await _prepareCompletion(
+        '}',
+        '''
+main() {
+  do {
   }
 }
 ''',
-        (s) => s.indexOf('    ') + '    '.length);
+        atEnd: true);
+    _assertHasChange(
+        'Complete do-statement',
+        '''
+main() {
+  do {
+  } while ();
+}
+''',
+        (s) => s.indexOf('while (') + 'while ('.length);
   }
 
   test_completeIfAfterCondition_BAD() async {
     // TODO(messick): Fix the code to make this like test_completeIfWithCondition.
     // Recap: Finding the node at the selectionOffset returns the block, not the
     // if-statement. Need to understand if that only happens when the if-statement
     // is the only statement in the block, or perhaps first or last? And what
     // happens when it is in the middle of other statements?
     await _prepareCompletion(
         'if (true) ', // Trigger completion after space.
         '''
 main() {
   if (true) ////
 }
 ''',
         atEnd: true);
     _assertHasChange(
         // Note: This is not what we want.
         'Insert a newline at the end of the current line',
         '''
 main() {
   if (true) ////
   }
 }
 ''',
         (s) => s.indexOf('if (true) ') + 'if (true) '.length);
   }
 
+  test_completeIfEmptyCondition() async {
+    await _prepareCompletion(
+        'if ()',
+        '''
+main() {
+  if ()
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete if-statement',
+        '''
+main() {
+  if () {
+    ////
+  }
+}
+''',
+        (s) => s.indexOf('if (') + 'if ('.length);
+  }
+
+  test_completeIfKeywordOnly() async {
+    await _prepareCompletion(
+        'if',
+        '''
+main() {
+  if ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete if-statement',
+        '''
+main() {
+  if () {
+    ////
+  }
+}
+''',
+        (s) => s.indexOf('if (') + 'if ('.length);
+  }
+
+  test_completeIfWithCondition() async {
+    await _prepareCompletion(
+        'if (tr', // Trigger completion from within expression.
+        '''
+main() {
+  if (true)
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete if-statement',
+        '''
+main() {
+  if (true) {
+    ////
+  }
+}
+''',
+        (s) => s.indexOf('    ') + '    '.length);
+  }
+
   test_completeIfWithElse_BAD() async {
     await _prepareCompletion(
         'if ()',
         '''
 main() {
   if ()
   else
 }
 ''',
         atEnd: true);
@@ skipping 139 matching lines @@
     }
     await _prepareCompletionAt(offset + delta, testCode);
   }
 
   _prepareCompletionAt(int offset, String sourceCode) async {
     verifyNoTestUnitErrors = false;
     await resolveTestUnit(sourceCode);
     await _computeCompletion(offset);
   }
 }