Follow a consistent user model

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(_DeclarationCompletionTest);
     defineReflectiveTests(_ControlFlowCompletionTest);
     defineReflectiveTests(_DoCompletionTest);
+    defineReflectiveTests(_ExpressionCompletionTest);
     defineReflectiveTests(_ForCompletionTest);
     defineReflectiveTests(_ForEachCompletionTest);
     defineReflectiveTests(_IfCompletionTest);
     defineReflectiveTests(_SimpleCompletionTest);
     defineReflectiveTests(_SwitchCompletionTest);
     defineReflectiveTests(_TryCompletionTest);
     defineReflectiveTests(_WhileCompletionTest);
   });
 }
 
@@ skipping 266 matching lines @@
     _assertHasChange(
         'Complete class declaration',
         '''
 class Sample {
   ////
 }
 ''',
         (s) => _afterLast(s, '  '));
   }
 
+  test_extendsNoBody() async {
+    await _prepareCompletion(
+        'Sample',
+        '''
+class Sample extends Object
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete class declaration',
+        '''
+class Sample extends Object {
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
   test_functionDeclNoBody() async {
     await _prepareCompletion(
         'source()',
         '''
 String source()
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete function declaration',
         '''
 String source() {
   ////
 }
 ''',
         (s) => _after(s, '  '));
   }
 
+  test_functionDeclNoParen() async {
+    await _prepareCompletion(
+        'source(',
+        '''
+String source(
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete function declaration',
+        '''
+String source() {
+  ////
+}
+''',
+        (s) => _after(s, '  '));
+  }
+
   test_methodDeclNoBody() async {
     await _prepareCompletion(
         'source()',
         '''
 class Sample {
   String source()
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete function declaration',
         '''
 class Sample {
   String source() {
     ////
   }
 }
 ''',
         (s) => _after(s, '    '));
   }
 
+  test_methodDeclNoParen() async {
+    await _prepareCompletion(
+        'source(',
+        '''
+class Sample {
+  String source(
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete function declaration',
+        '''
+class Sample {
+  String source() {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
   test_variableDeclNoBody() async {
     await _prepareCompletion(
         'source',
         '''
 String source
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete variable declaration',
         '''
 String source;
 ////
 ''',
         (s) => _after(s, ';\n'));
   }
+
+  test_withNoBody() async {

[Brian Wilkerson, 2017/05/09 15:12:24]

Is there a test for the following?

  class Interface {}
  class Sample implements Interface

[messick, 2017/05/09 16:32:09]

Done.

+    await _prepareCompletion(
+        'Sample',
+        '''
+class M {}
+class Sample extends Object with M
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete class declaration',
+        '''
+class M {}
+class Sample extends Object with M {
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
 }
 
 @reflectiveTest
 class _DoCompletionTest extends StatementCompletionTest {
   test_emptyCondition() async {
     await _prepareCompletion(
         'while ()',
         '''
 main() {
   do {
@@ skipping 115 matching lines @@
 main() {
   do {
   } while ();
 }
 ''',
         (s) => _after(s, 'while ('));
   }
 }
 
 @reflectiveTest
+class _ExpressionCompletionTest extends StatementCompletionTest {
+  test_listAssign() async {
+    await _prepareCompletion(
+        '= ',
+        '''
+main() {
+  var x = [1, 2, 3
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  var x = [1, 2, 3];
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_listAssignMultiLine() async {
+    // The indent of the final line is incorrect.
+    await _prepareCompletion(
+        '3',
+        '''
+main() {
+  var x = [
+    1,
+    2,
+    3
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  var x = [
+    1,
+    2,
+    3,
+  ];
+    ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  @failingTest
+  test_mapAssign() async {
+    await _prepareCompletion(
+        '3: 3',
+        '''
+main() {
+  var x = {1: 1, 2: 2, 3: 3
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  var x = {1: 1, 2: 2, 3: 3};
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  @failingTest
+  test_mapAssignMissingColon() async {
+    await _prepareCompletion(
+        '3',
+        '''
+main() {
+  var x = {1: 1, 2: 2, 3
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  var x = {1: 1, 2: 2, 3: };
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_returnString() async {
+    await _prepareCompletion(
+        'text',
+        '''
+main() {
+  if (done()) {
+    return 'text
+  }
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete control flow block',
+        '''
+main() {
+  if (done()) {
+    return 'text';
+  }
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_stringAssign() async {
+    await _prepareCompletion(
+        '= ',
+        '''
+main() {
+  var x = '
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Add a semicolon and newline',
+        '''
+main() {
+  var x = '';
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_stringSingle() async {
+    await _prepareCompletion(
+        'text',
+        '''
+main() {
+  print("text
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Insert a newline at the end of the current line',
+        '''
+main() {
+  print("text");
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+
+  test_stringTriple() async {
+    await _prepareCompletion(
+        'text',
+        '''
+main() {
+  print(\'\'\'text
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Insert a newline at the end of the current line',
+        '''
+main() {
+  print(\'\'\'text\'\'\');
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
+  }
+}
+
+@reflectiveTest
 class _ForCompletionTest extends StatementCompletionTest {
   test_emptyCondition() async {
     await _prepareCompletion(
-        '}',
+        '0;',
+        '''
+main() {
+  for (int i = 0;)      /**/  ////
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete for-statement',
+        '''
+main() {
+  for (int i = 0; ; ) /**/ {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
+  test_emptyConditionWithBody() async {
+    await _prepareCompletion(
+        '0;',
         '''
 main() {
   for (int i = 0;) {
   }
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
   for (int i = 0; ; ) {
   }
 }
 ''',
         (s) => _after(s, '0; '));
   }
 
   test_emptyInitializers() async {
-    // TODO(messick) This should insert a newline and move the cursor there.
+    // This does nothing, same as for Java.
     await _prepareCompletion(
-        '}',
+        'r (',
         '''
 main() {
   for () {
   }
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
   for () {
   }
 }
 ''',
-        (s) => _after(s, 'for ('));
+        (s) => _after(s, 'r ('));
+  }
+
+  test_emptyInitializersAfterBody() async {
+    await _prepareCompletion(
+        '}',
+        '''
+main() {
+  for () {
+  }
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Insert a newline at the end of the current line',
+        '''
+main() {
+  for () {
+  }
+  ////
+}
+''',
+        (s) => _afterLast(s, '  '));
   }
 
   test_emptyInitializersEmptyCondition() async {
     await _prepareCompletion(
-        '}',
+        '/**/',
         '''
 main() {
-  for (;/**/) {
-  }
+  for (;/**/)
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
-  for (;/**/) {
+  for (; /**/; ) {
+    ////
   }
 }
 ''',
-        (s) => _after(s, '/**/'));
+        (s) => _after(s, '    '));
   }
 
   test_emptyParts() async {
     await _prepareCompletion(
         ';)',
         '''
 main() {
   for (;;)
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
   for (;;) {
     ////
   }
 }
 ''',
         (s) => _after(s, '    '));
   }
 
   test_emptyUpdaters() async {
     await _prepareCompletion(
-        '}',
+        '/**/',
+        '''
+main() {
+  for (int i = 0; i < 10 /**/)
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete for-statement',
+        '''
+main() {
+  for (int i = 0; i < 10 /**/; ) {
+    ////
+  }
+}
+''',
+        (s) => _after(s, '    '));
+  }
+
+  test_emptyUpdatersWithBody() async {
+    await _prepareCompletion(
+        '/**/',
         '''
 main() {
   for (int i = 0; i < 10 /**/) {
   }
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
   for (int i = 0; i < 10 /**/; ) {
   }
 }
 ''',
-        (s) => _after(s, '10 /**/; '));
+        (s) => _after(s, '*/; '));
   }
 
   test_keywordOnly() async {
     await _prepareCompletion(
         'for',
         '''
 main() {
   for
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
   for () {
     ////
   }
 }
 ''',
         (s) => _after(s, 'for ('));
   }
 
   test_missingLeftSeparator() async {
     await _prepareCompletion(
-        '}',
+        '= 0',
         '''
 main() {
   for (int i = 0) {
   }
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete for-statement',
         '''
 main() {
-  for (int i = 0; ) {
+  for (int i = 0; ; ) {
   }
 }
 ''',
         (s) => _after(s, '0; '));
   }
 
   test_noError() async {
     await _prepareCompletion(
         ';)',
         '''
@@ skipping 101 matching lines @@
   }
   return;
 }
 ''',
         (s) => _after(s, '    '));
   }
 }
 
 @reflectiveTest
 class _IfCompletionTest extends StatementCompletionTest {
-  test_afterCondition_BAD() async {
-    // TODO(messick) Stop inserting the space after the closing brace.
+  test_afterCondition() async {
     await _prepareCompletion(
         'if (true) ', // Trigger completion after space.
         '''
 main() {
   if (true) ////
 }
 ''',
         atEnd: true);
     _assertHasChange(
         'Complete if-statement',
         '''
 main() {
   if (true) {
     ////
-  } ////
+  }
 }
 ''',
         (s) => _after(s, '    '));
   }
 
   test_emptyCondition() async {
     await _prepareCompletion(
         'if ()',
         '''
 main() {
@@ skipping 541 matching lines @@
   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_onCatchComment() async {
+    await _prepareCompletion(
+        'on',
+        '''
+main() {
+  try {
+  } on catch
+  //
+}
+''',
+        atEnd: true);
+    _assertHasChange(
+        'Complete try-statement',
+        '''
+main() {
+  try {
+  } on catch () {
+    ////
+  }
+  //
+}
+''',
+        (s) => _after(s, 'catch ('));
+  }
+
   test_onOnly() async {
     await _prepareCompletion(
         'on',
         '''
 main() {
   try {
   } on
 }
 ''',
         atEnd: true);
@@ skipping 103 matching lines @@
         '''
 main() {
   while () {
     ////
   }
 }
 ''',
         (s) => _after(s, 'while ('));
   }
 }