Initial work on refactorings.

pkg/analysis_services/test/correction/status_test.dart

Index: pkg/analysis_services/test/correction/status_test.dart
diff --git a/pkg/analysis_services/test/correction/status_test.dart b/pkg/analysis_services/test/correction/status_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..7ec854ade1056adbd00b2e448883d8b26b18fa61
--- /dev/null
+++ b/pkg/analysis_services/test/correction/status_test.dart
@@ -0,0 +1,294 @@
+// 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.
+
+// This code was auto-generated, is not intended to be edited, and is subject to
+// significant change. Please see the README file for more information.
+
+library test.services.correction.status;
+
+import 'package:analysis_services/correction/status.dart';
+import 'package:analysis_services/search/search_engine.dart';
+import 'package:analysis_services/src/correction/source_range.dart';
+import 'package:analysis_testing/abstract_single_unit.dart';
+import 'package:analysis_testing/reflective_tests.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:typed_mock/typed_mock.dart';
+import 'package:unittest/unittest.dart';
+
+
+main() {
+  groupSep = ' | ';
+  runReflectiveTests(RefactoringStatusContextTest);
+  runReflectiveTests(RefactoringStatusEntryTest);
+  runReflectiveTests(RefactoringStatusTest);
+}
+
+
+@ReflectiveTestCase()
+class RefactoringStatusContextTest extends AbstractSingleUnitTest {
+  void test_new_forElement() {
+    resolveTestUnit('class MyClass {}');
+    Element element = findElement('MyClass');
+    var statusContext = new RefactoringStatusContext.forElement(element);
+    // access
+    expect(statusContext.context, context);
+    expect(statusContext.source, testSource);
+    expect(
+        statusContext.range,
+        rangeStartLength(element.nameOffset, 'MyClass'.length));
+  }
+
+  void test_new_forMatch() {
+    resolveTestUnit('class MyClass {}');
+    Element element = findElement('MyClass');
+    SourceRange range = rangeElementName(element);
+    SearchMatch match = new SearchMatch(null, element, range, true, false);
+    var statusContext = new RefactoringStatusContext.forMatch(match);
+    // access
+    expect(statusContext.context, context);
+    expect(statusContext.source, testSource);
+    expect(statusContext.range, range);
+  }
+
+  void test_new_forNode() {
+    resolveTestUnit('''
+main() {
+}
+''');
+    AstNode node = findNodeAtString('main');
+    var statusContext = new RefactoringStatusContext.forNode(node);
+    // access
+    expect(statusContext.context, context);
+    expect(statusContext.source, testSource);
+    expect(statusContext.range, rangeNode(node));
+    // toString()
+    expect(
+        statusContext.toString(),
+        '[source=/test.dart, range=[offset=0, length=4]]');
+  }
+
+  void test_new_forUnit() {
+    resolveTestUnit('');
+    SourceRange range = rangeStartLength(10, 20);
+    var statusContext = new RefactoringStatusContext.forUnit(testUnit, range);
+    // access
+    expect(statusContext.context, context);
+    expect(statusContext.source, testSource);
+    expect(statusContext.range, range);
+    // toString()
+    expect(
+        statusContext.toString(),
+        '[source=/test.dart, range=[offset=10, length=20]]');
+  }
+}
+
+
+@ReflectiveTestCase()
+class RefactoringStatusEntryTest {
+  void test_new_withContext() {
+    RefactoringStatusContext context = new _MockRefactoringStatusContext();
+    RefactoringStatusEntry entry =
+        new RefactoringStatusEntry(
+            RefactoringStatusSeverity.ERROR,
+            "my message",
+            context);
+    // access
+    expect(entry.severity, RefactoringStatusSeverity.ERROR);
+    expect(entry.message, 'my message');
+    expect(entry.context, context);
+    // toString()
+    entry.toString();
+  }
+
+  void test_new_withoutContext() {
+    RefactoringStatusEntry entry =
+        new RefactoringStatusEntry(RefactoringStatusSeverity.ERROR, "my message");
+    // access
+    expect(entry.severity, RefactoringStatusSeverity.ERROR);
+    expect(entry.message, 'my message');
+    expect(entry.context, isNull);
+    // isX
+    expect(entry.isFatalError, isFalse);
+    expect(entry.isError, isTrue);
+    expect(entry.isWarning, isFalse);
+    // toString()
+    entry.toString();
+  }
+}
+
+
+@ReflectiveTestCase()
+class RefactoringStatusTest {
+  void test_addError() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    // initial state
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.OK);
+    // add ERROR
+    refactoringStatus.addError('msg');
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.ERROR);
+    expect(refactoringStatus.isOK, isFalse);
+    expect(refactoringStatus.hasFatalError, isFalse);
+    expect(refactoringStatus.hasError, isTrue);
+    // entries
+    List<RefactoringStatusEntry> entries = refactoringStatus.entries;
+    expect(entries, hasLength(1));
+    expect(entries[0].message, 'msg');
+    // toString()
+    expect(refactoringStatus.toString(), '<ERROR\n\tERROR: msg\n>');
+  }
+
+  void test_addFatalError_withContext() {
+    RefactoringStatusContext context = new _MockRefactoringStatusContext();
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    // initial state
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.OK);
+    // add FATAL
+    refactoringStatus.addFatalError('msg', context);
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.FATAL);
+    expect(refactoringStatus.isOK, isFalse);
+    expect(refactoringStatus.hasFatalError, isTrue);
+    expect(refactoringStatus.hasError, isTrue);
+    // entries
+    List<RefactoringStatusEntry> entries = refactoringStatus.entries;
+    expect(entries, hasLength(1));
+    expect(entries[0].message, 'msg');
+    expect(entries[0].context, context);
+    // toString()
+    expect(
+        refactoringStatus.toString(),

[Brian Wilkerson, 2014/08/11 16:27:47]

I'm always hesitant to test things like toString. I don't think of toString as
part of the public API and don't believe that we should be constrained in terms
of the content of the returned string. (And it seems pointless to test
characteristics that are allowed to change.)

[scheglov, 2014/08/11 18:06:25]

Acknowledged.

+        '<FATAL\n\tFATAL: msg; Context: MockRefactoringStatusContext\n>');
+    // add WARNING, resulting severity is still FATAL
+    refactoringStatus.addWarning("warning");
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.FATAL);
+  }
+
+  void test_addFatalError_withoutContext() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    // initial state
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.OK);
+    // add FATAL
+    refactoringStatus.addFatalError('msg');
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.FATAL);
+    expect(refactoringStatus.isOK, isFalse);
+    expect(refactoringStatus.hasFatalError, isTrue);
+    expect(refactoringStatus.hasError, isTrue);
+    // entries
+    List<RefactoringStatusEntry> entries = refactoringStatus.entries;
+    expect(entries, hasLength(1));
+    expect(entries[0].message, 'msg');
+    expect(entries[0].context, isNull);
+  }
+
+  void test_addWarning() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    // initial state
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.OK);
+    // add WARNING
+    refactoringStatus.addWarning('msg');
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.WARNING);
+    expect(refactoringStatus.isOK, isFalse);
+    expect(refactoringStatus.hasFatalError, isFalse);
+    expect(refactoringStatus.hasError, isFalse);
+    expect(refactoringStatus.hasWarning, isTrue);
+    // entries
+    List<RefactoringStatusEntry> entries = refactoringStatus.entries;
+    expect(entries, hasLength(1));
+    expect(entries[0].message, 'msg');
+  }
+
+  void test_createErrorStatus() {
+    RefactoringStatusContext context = new _MockRefactoringStatusContext();
+    RefactoringStatus refactoringStatus = createErrorStatus('msg', context);
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.ERROR);
+    expect(refactoringStatus.message, 'msg');
+    expect(refactoringStatus.entryWithHighestSeverity.context, context);
+  }
+
+  void test_createFatalErrorStatus() {
+    RefactoringStatus refactoringStatus = createFatalErrorStatus('msg');
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.FATAL);
+    expect(refactoringStatus.message, 'msg');
+  }
+
+  void test_createWarningStatus() {
+    RefactoringStatus refactoringStatus = createWarningStatus('msg');
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.WARNING);
+    expect(refactoringStatus.message, 'msg');
+  }
+
+  void test_escalateErrorToFatal() {
+    RefactoringStatus refactoringStatus = createErrorStatus('msg');
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.ERROR);
+    // escalated
+    RefactoringStatus escalated = refactoringStatus.escalateErrorToFatal();
+    expect(escalated.severity, RefactoringStatusSeverity.FATAL);
+  }
+
+  void test_get_entryWithHighestSeverity() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    // no entries
+    expect(refactoringStatus.entryWithHighestSeverity, isNull);
+    expect(refactoringStatus.message, isNull);
+    // add entries
+    refactoringStatus.addError('msgError');
+    refactoringStatus.addWarning('msgWarning');
+    refactoringStatus.addFatalError('msgFatalError');
+    // get entry
+    {
+      RefactoringStatusEntry entry = refactoringStatus.entryWithHighestSeverity;
+      expect(entry.severity, RefactoringStatusSeverity.FATAL);
+      expect(entry.message, 'msgFatalError');
+    }
+    // get message
+    expect(refactoringStatus.message, 'msgFatalError');
+  }
+
+  void test_merge_Error_withWarning() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    refactoringStatus.addError("err");
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.ERROR);
+    // merge with OK
+    {
+      RefactoringStatus other = new RefactoringStatus();
+      other.addWarning("warn");
+      refactoringStatus.merge(other);
+    }
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.ERROR);
+    expect(refactoringStatus.message, 'err');
+  }
+
+  void test_merge_Warning_null() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    refactoringStatus.addWarning("warn");
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.WARNING);
+    // merge with "null"
+    refactoringStatus.merge(null);
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.WARNING);
+  }
+
+  void test_merge_Warning_withError() {
+    RefactoringStatus refactoringStatus = new RefactoringStatus();
+    refactoringStatus.addWarning("warn");
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.WARNING);
+    // merge with OK
+    {
+      RefactoringStatus other = new RefactoringStatus();
+      other.addError("err");
+      refactoringStatus.merge(other);
+    }
+    expect(refactoringStatus.severity, RefactoringStatusSeverity.ERROR);
+    expect(refactoringStatus.message, 'err');
+  }
+}
+
+
+class _MockRefactoringStatusContext extends TypedMock implements
+    RefactoringStatusContext {
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+
+  @override
+  String toString() => 'MockRefactoringStatusContext';
+}