Compete try-statements

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(_DoCompletionTest);
     defineReflectiveTests(_ForCompletionTest);
     defineReflectiveTests(_ForEachCompletionTest);
     defineReflectiveTests(_IfCompletionTest);
     defineReflectiveTests(_SimpleCompletionTest);
     defineReflectiveTests(_SwitchCompletionTest);
+    defineReflectiveTests(_TryCompletionTest);
     defineReflectiveTests(_WhileCompletionTest);
   });
 }
 
 class StatementCompletionTest extends AbstractSingleUnitTest {
   SourceChange change;
 
   bool get enableNewAnalysisDriver => true;
 
   int _after(String source, String match) =>
@@ skipping 621 matching lines @@
   switch () {
     ////
   }
 }
 ''',
         (s) => _after(s, 'switch ('));
   }
 }
 
 @reflectiveTest
+class _TryCompletionTest extends StatementCompletionTest {
+  test_catchOnly() async {
+    await _prepareCompletion(
+        'catch',
+        '''
+main() {
+  try {
+  } catch(e){} catch ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } catch(e){} catch () {
+    ////
+  }
+}
+''',
+        (s) => _after(s, 'catch ('));
+  }
+
+  test_finallyOnly() async {
+    await _prepareCompletion(
+        'finally',
+        '''
+main() {
+  try {
+  } finally
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } finally {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
+  test_keywordOnly() async {
+    await _prepareCompletion(
+        'try',
+        '''
+main() {
+  try////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
+  test_keywordSpace() async {
+    await _prepareCompletion(
+        'try',
+        '''
+main() {
+  try ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
+  test_onCatch() async {
+    await _prepareCompletion(
+        'on',
+        '''
+main() {
+  try {
+  } on catch
+}
+''',
+        atEnd: true);
+    // It would be better to expect the cursor to follow the on-keyword but
+    // the parser thinks the exception type is 'catch' so it's kinda broken.
+    // See https://github.com/dart-lang/sdk/issues/29410
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } on catch () {
+    ////
+  }
+}
+''',
+        (s) => _after(s, 'catch ('));
+  }
+
+  test_onOnly() async {
+    await _prepareCompletion(
+        'on',
+        '''
+main() {
+  try {
+  } on
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } on  {
+    ////
+  }
+}
+''',
+        (s) => _after(s, ' on '));
+  }
+
+  test_onSpace() async {
+    await _prepareCompletion(
+        'on',
+        '''
+main() {
+  try {
+  } on ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } on  {
+    ////
+  }
+}
+''',
+        (s) => _after(s, ' on '));
+  }
+
+  test_onSpaces() async {
+    await _prepareCompletion(
+        'on',
+        '''
+main() {
+  try {
+  } on  ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } on  {
+    ////
+  }
+}
+''',
+        (s) => _after(s, ' on '));
+  }
+
+  test_onType() async {
+    await _prepareCompletion(
+        'on',
+        '''
+main() {
+  try {
+  } on Exception
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } on Exception {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+}
+
+@reflectiveTest
 class _WhileCompletionTest extends StatementCompletionTest {
   /*
      The implementation of completion for while-statements is shared with
      if-statements. Here we check that the wrapper for while-statements
      functions as expected. The individual test cases are covered by the
      _IfCompletionTest tests. If the implementation changes then the same
      set of tests defined for if-statements should be duplicated here.
    */
   test_keywordOnly() async {
     await _prepareCompletion(
         'while',
         '''
 main() {
   while ////
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete while-statement',
         '''
 main() {
   while () {
     ////
   }
 }
 ''',
         (s) => _after(s, 'while ('));
   }
 }