Removed fixed dependencies

packages/analyzer/test/generated/test_support.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 engine.test_support;
+library analyzer.test.generated.test_support;
 
 import 'dart:collection';
 
-import 'package:analyzer/src/generated/ast.dart' show AstNode, NodeLocator;
-import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/dart/ast/ast.dart' show AstNode, SimpleIdentifier;
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/error/error.dart';
+import 'package:analyzer/error/listener.dart';
+import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/generated/engine.dart';
-import 'package:analyzer/src/generated/error.dart';
-import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:plugin/manager.dart';
+import 'package:plugin/plugin.dart';
 import 'package:unittest/unittest.dart';
 
-import 'resolver_test.dart';
+import 'analysis_context_factory.dart';
 
 /**
  * The class `EngineTestCase` defines utility methods for making assertions.
  */
 class EngineTestCase {
   /**
    * Assert that the given collection has the same number of elements as the number of specified
    * names, and that for each specified name, a corresponding element can be found in the given
    * collection with that name.
    *
@@ skipping 55 matching lines @@
   MethodElement getMethod(InterfaceType type, String methodName) {
     for (MethodElement method in type.element.methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     fail("Could not find method named $methodName in ${type.displayName}");
     return null;
   }
 
-  void setUp() {}
+  void setUp() {
+    List<Plugin> plugins = <Plugin>[];
+    plugins.addAll(AnalysisEngine.instance.requiredPlugins);
+    plugins.add(AnalysisEngine.instance.commandLinePlugin);
+    plugins.add(AnalysisEngine.instance.optionsPlugin);
+    new ExtensionManager().processPlugins(plugins);
+  }
 
   void tearDown() {}
 
   /**
    * Assert that the given object is an instance of the expected class.
    *
    * @param expectedClass the class that the object is expected to be an instance of
    * @param object the object being tested
    * @return the object that was being tested
    * @throws Exception if the object is not an instance of the expected class
    */
   static Object assertInstanceOf(
       Predicate<Object> predicate, Type expectedClass, Object object) {
     if (!predicate(object)) {
       fail(
           "Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
     }
     return object;
   }
 
   /**
    * @return the [AstNode] with requested type at offset of the "prefix".
    */
   static AstNode findNode(
       AstNode root, String code, String prefix, Predicate<AstNode> predicate) {
     int offset = code.indexOf(prefix);
     if (offset == -1) {
-      throw new IllegalArgumentException("Not found '$prefix'.");
+      throw new ArgumentError("Not found '$prefix'.");
     }
     AstNode node = new NodeLocator(offset).searchWithin(root);
     return node.getAncestor(predicate);
   }
+
+  /**
+   * Find the [SimpleIdentifier] with at offset of the "prefix".
+   */
+  static SimpleIdentifier findSimpleIdentifier(
+      AstNode root, String code, String prefix) {
+    int offset = code.indexOf(prefix);
+    if (offset == -1) {
+      throw new ArgumentError("Not found '$prefix'.");
+    }
+    return new NodeLocator(offset).searchWithin(root);
+  }
 }
 
 /**
  * Instances of the class `GatheringErrorListener` implement an error listener that collects
  * all of the errors passed to it for later examination.
  */
 class GatheringErrorListener implements AnalysisErrorListener {
   /**
    * An empty array of errors used when no errors are expected.
    */
@@ skipping 249 matching lines @@
    * Set the line information associated with the given source to the given information.
    *
    * @param source the source with which the line information is associated
    * @param lineStarts the line start information to be associated with the source
    */
   void setLineInfo(Source source, List<int> lineStarts) {
     _lineInfoMap[source] = new LineInfo(lineStarts);
   }
 
   /**
-   * Return `true` if the two errors are equivalent.
-   *
-   * @param firstError the first error being compared
-   * @param secondError the second error being compared
-   * @return `true` if the two errors are equivalent
+   * Return `true` if the [actualError] matches the [expectedError].
    */
-  bool _equalErrors(AnalysisError firstError, AnalysisError secondError) =>
-      identical(firstError.errorCode, secondError.errorCode) &&
-          firstError.offset == secondError.offset &&
-          firstError.length == secondError.length &&
-          _equalSources(firstError.source, secondError.source);
+  bool _equalErrors(AnalysisError expectedError, AnalysisError actualError) {
+    Source expectedSource = expectedError.source;
+    return identical(expectedError.errorCode, actualError.errorCode) &&
+        expectedError.offset == actualError.offset &&
+        expectedError.length == actualError.length &&
+        (expectedSource == null ||
+            _equalSources(expectedSource, actualError.source));
+  }
 
   /**
    * Return `true` if the two sources are equivalent.
    *
    * @param firstSource the first source being compared
    * @param secondSource the second source being compared
    * @return `true` if the two sources are equivalent
    */
   bool _equalSources(Source firstSource, Source secondSource) {
     if (firstSource == null) {
@@ skipping 14 matching lines @@
    */
   void _fail(List<AnalysisError> expectedErrors) {
     StringBuffer buffer = new StringBuffer();
     buffer.write("Expected ");
     buffer.write(expectedErrors.length);
     buffer.write(" errors:");
     for (AnalysisError error in expectedErrors) {
       Source source = error.source;
       LineInfo lineInfo = _lineInfoMap[source];
       buffer.writeln();
+      String sourceName = source == null ? '' : source.shortName;
       if (lineInfo == null) {
         int offset = error.offset;
-        StringUtils.printf(buffer, "  %s %s (%d..%d)", [
-          source == null ? "" : source.shortName,
-          error.errorCode,
-          offset,
-          offset + error.length
-        ]);
+        buffer.write('  $sourceName ${error.errorCode} '
+            '($offset..${offset + error.length})');
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        StringUtils.printf(buffer, "  %s %s (%d, %d/%d)", [
-          source == null ? "" : source.shortName,
-          error.errorCode,
-          location.lineNumber,
-          location.columnNumber,
-          error.length
-        ]);
+        int lineNumber = location.lineNumber;
+        int columnNumber = location.columnNumber;
+        buffer.write('  $sourceName ${error.errorCode} '
+            '($lineNumber, $columnNumber/${error.length})');
       }
     }
     buffer.writeln();
     buffer.write("found ");
     buffer.write(_errors.length);
     buffer.write(" errors:");
     for (AnalysisError error in _errors) {
       Source source = error.source;
       LineInfo lineInfo = _lineInfoMap[source];
       buffer.writeln();
+      String sourceName = source == null ? '' : source.shortName;
       if (lineInfo == null) {
         int offset = error.offset;
-        StringUtils.printf(buffer, "  %s %s (%d..%d): %s", [
-          source == null ? "" : source.shortName,
-          error.errorCode,
-          offset,
-          offset + error.length,
-          error.message
-        ]);
+        buffer.write('  $sourceName ${error.errorCode} '
+            '($offset..${offset + error.length}): ${error.message}');
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        StringUtils.printf(buffer, "  %s %s (%d, %d/%d): %s", [
-          source == null ? "" : source.shortName,
-          error.errorCode,
-          location.lineNumber,
-          location.columnNumber,
-          error.length,
-          error.message
-        ]);
+        int lineNumber = location.lineNumber;
+        int columnNumber = location.columnNumber;
+        buffer.write('  $sourceName ${error.errorCode} '
+            '($lineNumber, $columnNumber/${error.length}): ${error.message}');
       }
     }
     fail(buffer.toString());
   }
 
   /**
    * Search through the given list of errors for an error that is equal to the target error. If one
    * is found, remove it from the list and return `true`, otherwise return `false`
    * without modifying the list.
    *
@@ skipping 11 matching lines @@
     return false;
   }
 }
 
 /**
  * Instances of the class [TestLogger] implement a logger that can be used by
  * tests.
  */
 class TestLogger implements Logger {
   /**
-   * The number of error messages that were logged.
+   * All logged messages.
    */
-  int errorCount = 0;
-
-  /**
-   * The number of informational messages that were logged.
-   */
-  int infoCount = 0;
+  List<String> log = [];
 
   @override
   void logError(String message, [CaughtException exception]) {
-    errorCount++;
-  }
-
-  @override
-  void logError2(String message, Object exception) {
-    errorCount++;
+    log.add("error: $message");
   }
 
   @override
   void logInformation(String message, [CaughtException exception]) {
-    infoCount++;
-  }
-
-  @override
-  void logInformation2(String message, Object exception) {
-    infoCount++;
+    log.add("info: $message");
   }
 }
 
 class TestSource extends Source {
   String _name;
   String _contents;
   int _modificationStamp = 0;
   bool exists2 = true;
 
   /**
    * A flag indicating whether an exception should be generated when an attempt
    * is made to access the contents of this source.
    */
   bool generateExceptionOnRead = false;
 
-  @override
-  int get modificationStamp =>
-      generateExceptionOnRead ? -1 : _modificationStamp;
-
   /**
    * The number of times that the contents of this source have been requested.
    */
   int readCount = 0;
 
   TestSource([this._name = '/test.dart', this._contents]);
 
   TimestampedData<String> get contents {
     readCount++;
     if (generateExceptionOnRead) {
       String msg = "I/O Exception while getting the contents of " + _name;
       throw new Exception(msg);
     }
     return new TimestampedData<String>(0, _contents);
   }
 
-  String get encoding {
-    throw new UnsupportedOperationException();
-  }
+  String get encoding => _name;
 
   String get fullName {
     return _name;
   }
 
   int get hashCode => 0;
+
   bool get isInSystemLibrary {
     return false;
   }
 
+  @override
+  int get modificationStamp =>
+      generateExceptionOnRead ? -1 : _modificationStamp;
+
   String get shortName {
     return _name;
   }
 
-  Uri get uri {
-    throw new UnsupportedOperationException();
-  }
+  Uri get uri => new Uri.file(_name);
 
   UriKind get uriKind {
-    throw new UnsupportedOperationException();
+    throw new UnsupportedError('uriKind');
   }
 
   bool operator ==(Object other) {
     if (other is TestSource) {
       return other._name == _name;
     }
     return false;
   }
 
   bool exists() => exists2;
   void getContentsToReceiver(Source_ContentReceiver receiver) {
-    throw new UnsupportedOperationException();
+    throw new UnsupportedError('getContentsToReceiver');
   }
 
   Source resolve(String uri) {
-    throw new UnsupportedOperationException();
-  }
-
-  Uri resolveRelativeUri(Uri uri) {
-    return new Uri(scheme: 'file', path: _name).resolveUri(uri);
+    throw new UnsupportedError('resolve');
   }
 
   void setContents(String value) {
     generateExceptionOnRead = false;
     _modificationStamp = new DateTime.now().millisecondsSinceEpoch;
     _contents = value;
   }
 
   @override
   String toString() => '$_name';
 }
 
 class TestSourceWithUri extends TestSource {
   final Uri uri;
 
   TestSourceWithUri(String path, this.uri, [String content])
       : super(path, content);
 
+  String get encoding => uri.toString();
+
   UriKind get uriKind {
     if (uri == null) {
       return UriKind.FILE_URI;
     } else if (uri.scheme == 'dart') {
       return UriKind.DART_URI;
     } else if (uri.scheme == 'package') {
       return UriKind.PACKAGE_URI;
     }
     return UriKind.FILE_URI;
   }
 
   bool operator ==(Object other) {
     if (other is TestSource) {
       return other.uri == uri;
     }
     return false;
   }
-
-  Uri resolveRelativeUri(Uri uri) {
-    return this.uri.resolveUri(uri);
-  }
 }