Split refactoring problems into init, options and final.

pkg/analysis_server/test/edit/refactoring_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.edit.refactoring;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/edit/edit_domain.dart';
 import 'package:analysis_server/src/protocol.dart';
@@ skipping 79 matching lines @@
   test_nameWarning() {
     addTestFile('''
 main() {
   print(1 + 2);
 }
 ''');
     return getRefactoringResult(() {
       return sendStringRequest('1 + 2', 'Name', true);
     }).then((result) {
       assertResultProblemsWarning(
-          result,
+          result.optionsProblems,
           'Variable name should start with a lowercase letter.');
       // ...but there is still a change
       assertTestRefactoringResult(result, '''
 main() {
   var Name = 1 + 2;
   print(Name);
 }
 ''');
     });
   }
@@ skipping 443 matching lines @@
       expect(feedback.occurrences, 2);
     });
   }
 
   test_init_fatalError_notVariable() {
     addTestFile('main() {}');
     return getRefactoringResult(() {
       return _sendInlineRequest('main() {}');
     }).then((result) {
       assertResultProblemsFatal(
-          result,
+          result.initialProblems,
           'Local variable declaration or reference must be selected to activate this refactoring.');
       // ...there is no any change
       expect(result.change, isNull);
     });
   }
 
   Future<Response> _sendInlineRequest(String search) {
     Request request = new EditGetRefactoringParams(
         RefactoringKind.INLINE_LOCAL_VARIABLE,
         testFile,
@@ skipping 30 matching lines @@
       expect(feedback.isDeclaration, isTrue);
     });
   }
 
   test_init_fatalError_noMethod() {
     addTestFile('// nothing to inline');
     return getRefactoringResult(() {
       return _sendInlineRequest('// nothing');
     }).then((result) {
       assertResultProblemsFatal(
-          result,
+          result.initialProblems,
           'Method declaration or reference must be selected to activate this refactoring.');
       // ...there is no any change
       expect(result.change, isNull);
     });
   }
 
   test_method() {
     addTestFile('''
 class A {
   int f;
@@ skipping 204 matching lines @@
   test_class_options_fatalError() {
     addTestFile('''
 class Test {}
 main() {
   Test v;
 }
 ''');
     return getRefactoringResult(() {
       return sendRenameRequest('Test {}', '');
     }).then((result) {
-      assertResultProblemsFatal(result, 'Class name must not be empty.');
+      assertResultProblemsFatal(
+          result.optionsProblems,
+          'Class name must not be empty.');
       // ...there is no any change
       expect(result.change, isNull);
     });
   }
 
   test_class_validateOnly() {
     addTestFile('''
 class Test {}
 main() {
   Test v;
@@ skipping 14 matching lines @@
     addTestFile('''
 class Test {}
 main() {
   Test v;
 }
 ''');
     return getRefactoringResult(() {
       return sendRenameRequest('Test {}', 'newName');
     }).then((result) {
       assertResultProblemsWarning(
-          result,
+          result.optionsProblems,
           'Class name should start with an uppercase letter.');
       // ...but there is still a change
       assertTestRefactoringResult(result, '''
 class newName {}
 main() {
   newName v;
 }
 ''');
     }).then((_) {
       // "NewName" is a perfectly valid name
@@ skipping 69 matching lines @@
   print(newName);
 }
 ''');
   }
 
   test_init_fatalError_noElement() {
     addTestFile('// nothing to rename');
     return getRefactoringResult(() {
       return sendRenameRequest('// nothing', null);
     }).then((result) {
-      assertResultProblemsFatal(result, 'Unable to create a refactoring');
+      assertResultProblemsFatal(
+          result.initialProblems,
+          'Unable to create a refactoring');
       // ...there is no any change
       expect(result.change, isNull);
     });
   }
 
   test_localVariable() {
     addTestFile('''
 main() {
   int test = 0;
   test = 1;
@@ skipping 17 matching lines @@
     addTestFile('''
 main() {
   var newName;
   int test = 0;
   print(test);
 }
 ''');
     return getRefactoringResult(() {
       return sendRenameRequest('test = 0', 'newName');
     }).then((result) {
-      assertResultProblemsError(result, "Duplicate local variable 'newName'.");
+      assertResultProblemsError(
+          result.finalProblems,
+          "Duplicate local variable 'newName'.");
     });
   }
 }
 
 
 @ReflectiveTestCase()
 class _AbstractGetRefactoring_Test extends AbstractAnalysisTest {
   /**
-   * Asserts that [result] has a single ERROR problem.
+   * Asserts that [problems] has a single ERROR problem.
    */
-  void assertResultProblemsError(EditGetRefactoringResult result,
+  void assertResultProblemsError(List<RefactoringProblem> problems,
       [String message]) {
-    List<RefactoringProblem> problems = result.problems;
     RefactoringProblem problem = problems[0];
     expect(problems, hasLength(1));
     expect(
         problem.severity,
         RefactoringProblemSeverity.ERROR,
         reason: problem.toString());
     if (message != null) {
       expect(problem.message, message);
     }
   }
 
   /**
    * Asserts that [result] has a single FATAL problem.
    */
-  void assertResultProblemsFatal(EditGetRefactoringResult result,
+  void assertResultProblemsFatal(List<RefactoringProblem> problems,
       [String message]) {
-    List<RefactoringProblem> problems = result.problems;
     RefactoringProblem problem = problems[0];
     expect(problems, hasLength(1));
     expect(
         problem.severity,
         RefactoringProblemSeverity.FATAL,
         reason: problem.toString());
     if (message != null) {
       expect(problem.message, message);
     }
   }
 
   /**
    * Asserts that [result] has no problems at all.
    */
   void assertResultProblemsOK(EditGetRefactoringResult result) {
-    expect(result.problems, isEmpty);
+    expect(result.initialProblems, isEmpty);
+    expect(result.optionsProblems, isEmpty);
+    expect(result.finalProblems, isEmpty);
   }
 
   /**
    * Asserts that [result] has a single WARNING problem.
    */
-  void assertResultProblemsWarning(EditGetRefactoringResult result,
+  void assertResultProblemsWarning(List<RefactoringProblem> problems,
       [String message]) {
-    List<RefactoringProblem> problems = result.problems;
     RefactoringProblem problem = problems[0];
     expect(problems, hasLength(1));
     expect(
         problem.severity,
         RefactoringProblemSeverity.WARNING,
         reason: problem.toString());
     if (message != null) {
       expect(problem.message, message);
     }
   }
@@ skipping 51 matching lines @@
   }
 
   @override
   void setUp() {
     super.setUp();
     server.handlers = [new EditDomainHandler(server),];
     createProject();
     handler = new EditDomainHandler(server);
   }
 }