Translate private Java members to private Dart members.

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 'package:analyzer/src/generated/java_core.dart';
@@ skipping 66 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 and locations. The order in which the errors
    * were gathered is ignored.
    *
    * @param errorCodes the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    *           expected or if they do not have the same codes and locations
    */
   void assertErrors(List<AnalysisError> expectedErrors) {
     if (_errors.length != expectedErrors.length) {
-      fail(expectedErrors);
+      _fail(expectedErrors);
     }
     List<AnalysisError> remainingErrors = new List<AnalysisError>();
     for (AnalysisError error in expectedErrors) {
       remainingErrors.add(error);
     }
     for (AnalysisError error in _errors) {
-      if (!foundAndRemoved(remainingErrors, error)) {
-        fail(expectedErrors);
+      if (!_foundAndRemoved(remainingErrors, error)) {
+        _fail(expectedErrors);
       }
     }
   }
 
   /**
    * 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 expectedErrorCodes the error codes of the errors that should have been gathered
@@ skipping 190 matching lines @@
     _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
    */
-  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 firstError, AnalysisError secondError) => identical(firstError.errorCode, secondError.errorCode) && firstError.offset == secondError.offset && firstError.length == secondError.length && _equalSources(firstError.source, secondError.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) {
+  bool _equalSources(Source firstSource, Source secondSource) {
     if (firstSource == null) {
       return secondSource == null;
     } else if (secondSource == null) {
       return false;
     }
     return firstSource == secondSource;
   }
 
   /**
    * 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) {
+  void _fail(List<AnalysisError> expectedErrors) {
     PrintStringWriter writer = new PrintStringWriter();
     writer.print("Expected ");
     writer.print(expectedErrors.length);
     writer.print(" errors:");
     for (AnalysisError error in expectedErrors) {
       Source source = error.source;
       LineInfo lineInfo = _lineInfoMap[source];
       writer.newLine();
       if (lineInfo == null) {
         int offset = error.offset;
@@ skipping 44 matching lines @@
 
   /**
    * 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
    */
-  bool foundAndRemoved(List<AnalysisError> errors, AnalysisError targetError) {
+  bool _foundAndRemoved(List<AnalysisError> errors, AnalysisError targetError) {
     for (AnalysisError error in errors) {
-      if (equalErrors(error, targetError)) {
+      if (_equalErrors(error, targetError)) {
         errors.remove(error);
         return true;
       }
     }
     return true;
   }
 }
 
 /**
  * The class `EngineTestCase` defines utility methods for making assertions.
@@ skipping 48 matching lines @@
   static void assertContains(List<Object> array, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (array == null) {
       JUnitTestCase.fail("Expected array of length ${expectedSize}; found null");
     }
     if (array.length != expectedSize) {
       JUnitTestCase.fail("Expected array of length ${expectedSize}; contained ${array.length} elements");
     }
     List<bool> found = new List<bool>.filled(expectedSize, false);
     for (int i = 0; i < expectedSize; i++) {
-      privateAssertContains(array, found, expectedElements[i]);
+      _privateAssertContains(array, found, expectedElements[i]);
     }
   }
 
   /**
    * Assert that the array of actual values contain exactly the same values as those in the array of
    * expected value, with the exception that the order of the elements is not required to be the
    * same.
    *
    * @param expectedValues the values that are expected to be found
    * @param actualValues the actual values that are being compared against the expected values
@@ skipping 31 matching lines @@
     if (actual == null || expected == null) {
       if (identical(actual, expected)) {
         return;
       }
       if (actual == null) {
         JUnitTestCase.assertTrueMsg("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);
+    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);
       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 193 matching lines @@
     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) {
+  static int _getDiffPos(String str1, String str2) {
     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;
     }
     return diffPos;
   }
 
-  static void privateAssertContains(List<Object> array, List<bool> found, Object element) {
+  static void _privateAssertContains(List<Object> array, List<bool> found, Object element) {
     if (element == null) {
       for (int i = 0; i < array.length; i++) {
         if (!found[i]) {
           if (array[i] == null) {
             found[i] = true;
             return;
           }
         }
       }
       JUnitTestCase.fail("Does not contain null");
@@ skipping 92 matching lines @@
   Source resolveRelative(Uri uri) {
     throw new UnsupportedOperationException();
   }
   UriKind get uriKind {
     throw new UnsupportedOperationException();
   }
   TimestampedData<String> get contents {
     throw new UnsupportedOperationException();
   }
 }
-
-/**
- * Wrapper around [Function] which should be called with "target" and "arguments".
- */
-class MethodTrampoline {
-  int parameterCount;
-  Function trampoline;
-  MethodTrampoline(this.parameterCount, this.trampoline);
-  Object invoke(target, List arguments) {
-    if (arguments.length != parameterCount) {
-      throw new IllegalArgumentException("${arguments.length} != $parameterCount");
-    }
-    switch (parameterCount) {
-      case 0:
-        return trampoline(target);
-      case 1:
-        return trampoline(target, arguments[0]);
-      case 2:
-        return trampoline(target, arguments[0], arguments[1]);
-      case 3:
-        return trampoline(target, arguments[0], arguments[1], arguments[2]);
-      case 4:
-        return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
-      default:
-        throw new IllegalArgumentException("Not implemented for > 4 arguments");
-    }
-  }
-}