Remove Math and most uses of PrintStringWriter

pkg/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.
 
 // 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 engine.test_support;
 
 import 'dart:collection';
+import "dart:math" as math;
 
 import 'package:analyzer/src/generated/ast.dart' show AstNode, NodeLocator;
 import 'package:analyzer/src/generated/element.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/java_junit.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 158 matching lines @@
             "Content not as expected: is 'null' expected: ${expected}",
             false);
       } else {
         JUnitTestCase.assertTrueMsg(
             "Content not as expected: expected 'null' is: ${actual}",
             false);
       }
     }
     int diffPos = _getDiffPos(expected, actual);
     if (diffPos != -1) {
-      int diffAhead = Math.max(0, diffPos - _PRINT_RANGE);
-      int diffAfter = Math.min(actual.length, diffPos + _PRINT_RANGE);
+      int diffAhead = math.max(0, diffPos - _PRINT_RANGE);
+      int diffAfter = math.min(actual.length, diffPos + _PRINT_RANGE);
       String diffStr =
           "${actual.substring(diffAhead, diffPos)}^${actual.substring(diffPos, diffAfter)}";
       // use detailed message
       String message =
           "Content not as expected: is\n${actual}\nDiffers at pos ${diffPos}: ${diffStr}\nexpected:\n${expected}";
       JUnitTestCase.assertEqualsMsg(message, expected, actual);
     }
   }
 
   /**
@@ skipping 216 matching lines @@
     }
   }
 
   /**
    * Convert the given array of lines into a single source string.
    *
    * @param lines the lines to be merged into a single source string
    * @return the source string composed of the given lines
    */
   static String createSource(List<String> lines) {
-    PrintStringWriter writer = new PrintStringWriter();
+    StringBuffer buffer = new StringBuffer();
     for (String line in lines) {
-      writer.println(line);
+      buffer.writeln(line);
     }
-    return writer.toString();
+    return buffer.toString();
   }
 
   /**
    * @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}'.");
     }
     AstNode node = new NodeLocator.con1(offset).searchWithin(root);
     return node.getAncestor(predicate);
   }
 
   /**
    * Calculate the offset where the given strings differ.
    *
    * @param str1 the first String to compare
    * @param str2 the second String to compare
    * @return the offset at which the strings differ (or <code>-1</code> if they do not)
    */
   static int _getDiffPos(String str1, String str2) {
-    int len1 = Math.min(str1.length, str2.length);
+    int len1 = math.min(str1.length, str2.length);
     int diffPos = -1;
     for (int i = 0; i < len1; i++) {
       if (str1.codeUnitAt(i) != str2.codeUnitAt(i)) {
         diffPos = i;
         break;
       }
     }
     if (diffPos == -1 && str1.length != str2.length) {
       diffPos = len1;
     }
@@ skipping 352 matching lines @@
 
   /**
    * Assert that the number of errors that have been gathered matches the number of errors that are
    * given and that they have the expected error codes. The order in which the errors were gathered
    * is ignored.
    *
    * @param errorCodes the errors that should have been gathered
    * @throws AssertionFailedError with
    */
   void _fail(List<AnalysisError> expectedErrors) {
-    PrintStringWriter writer = new PrintStringWriter();
-    writer.print("Expected ");
-    writer.print(expectedErrors.length);
-    writer.print(" errors:");
+    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];
-      writer.newLine();
+      buffer.writeln();
       if (lineInfo == null) {
         int offset = error.offset;
-        writer.printf(
+        StringUtils.printf(
+            buffer,
             "  %s %s (%d..%d)",
             [
                 source == null ? "" : source.shortName,
                 error.errorCode,
                 offset,
                 offset + error.length]);
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        writer.printf(
+        StringUtils.printf(
+            buffer,
             "  %s %s (%d, %d/%d)",
             [
                 source == null ? "" : source.shortName,
                 error.errorCode,
                 location.lineNumber,
                 location.columnNumber,
                 error.length]);
       }
     }
-    writer.newLine();
-    writer.print("found ");
-    writer.print(_errors.length);
-    writer.print(" errors:");
+    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];
-      writer.newLine();
+      buffer.writeln();
       if (lineInfo == null) {
         int offset = error.offset;
-        writer.printf(
+        StringUtils.printf(
+            buffer,
             "  %s %s (%d..%d): %s",
             [
                 source == null ? "" : source.shortName,
                 error.errorCode,
                 offset,
                 offset + error.length,
                 error.message]);
       } else {
         LineInfo_Location location = lineInfo.getLocation(error.offset);
-        writer.printf(
+        StringUtils.printf(
+            buffer,
             "  %s %s (%d, %d/%d): %s",
             [
                 source == null ? "" : source.shortName,
                 error.errorCode,
                 location.lineNumber,
                 location.columnNumber,
                 error.length,
                 error.message]);
       }
     }
-    JUnitTestCase.fail(writer.toString());
+    JUnitTestCase.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.
    *
    * @param errors the errors through which we are searching
    * @param targetError the error being searched for
    * @return `true` if the error is found and removed from the list
@@ skipping 106 matching lines @@
   void getContentsToReceiver(Source_ContentReceiver receiver) {
     throw new UnsupportedOperationException();
   }
   Source resolve(String uri) {
     throw new UnsupportedOperationException();
   }
   Uri resolveRelativeUri(Uri uri) {
     return new Uri(scheme: 'file', path: _name).resolveUri(uri);
   }
 }