Remove unused EngineTestCase.assertX() methods.

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/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 
 /**
  * The class `EngineTestCase` defines utility methods for making assertions.
  */
 class EngineTestCase {
-  static int _PRINT_RANGE = 6;
-
   void setUp() {}
 
   void tearDown() {}
 
   /**
    * 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.
    *
    * @param elements the elements
@@ skipping 57 matching lines @@
     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;
   }
 
   /**
-   * Assert that the tokens in the actual stream of tokens have the same types and lexemes as the
-   * tokens in the expected stream of tokens. Note that this does not assert anything about the
-   * offsets of the tokens (although the lengths will be equal).
-   *
-   * @param expectedStream the head of the stream of tokens that were expected
-   * @param actualStream the head of the stream of tokens that were actually found
-   * @throws AssertionFailedError if the two streams of tokens are not the same
-   */
-  static void assertAllMatch(Token expectedStream, Token actualStream) {
-    Token left = expectedStream;
-    Token right = actualStream;
-    while (left.type != TokenType.EOF && right.type != TokenType.EOF) {
-      assertMatches(left, right);
-      left = left.next;
-      right = right.next;
-    }
-  }
-
-  /**
    * Assert that the given array is non-`null` and contains the expected elements. The
    * elements can appear in any order.
    *
    * @param array the array being tested
    * @param expectedElements the expected elements
    * @throws AssertionFailedError if the array is `null` or does not contain the expected
    *           elements
    */
   static void assertContains(List<Object> array,
       List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (array == null) {
       fail("Expected array of length $expectedSize; found null");
     }
     if (array.length != expectedSize) {
       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]);
     }
   }
 
   /**
-   * Assert that a given String is equal to an expected value.
-   *
-   * @param expected the expected String value
-   * @param actual the actual String value
-   */
-  static void assertEqualString(String expected, String actual) {
-    if (actual == null || expected == null) {
-      if (identical(actual, expected)) {
-        return;
-      }
-      if (actual == null) {
-        fail("Content not as expected: is 'null' expected: $expected");
-      } else {
-        fail("Content not as expected: expected 'null' is: $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";
-      expect(actual, expected, reason: message);
-    }
-  }
-
-  /**
    * 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
    */
   static void assertEqualsIgnoreOrder(List<Object> expectedValues,
       List<Object> actualValues) {
     expect(actualValues, isNotNull);
@@ skipping 12 matching lines @@
           break;
         }
       }
       if (!wasExpected) {
         fail("The actual value $actualValue was not expected");
       }
     }
   }
 
   /**
-   * Assert that the given array is non-`null` and has exactly expected elements.
-   *
-   * @param array the array being tested
-   * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the array is `null` or does not have the expected
-   *           elements
-   */
-  static void assertExactElementsInArray(List<Object> array,
-      List<Object> expectedElements) {
-    int expectedSize = expectedElements.length;
-    if (array == null) {
-      fail("Expected array of size $expectedSize; found null");
-    }
-    if (array.length != expectedSize) {
-      fail("Expected array of size $expectedSize; contained ${array.length} elements");
-    }
-    for (int i = 0; i < expectedSize; i++) {
-      Object element = array[i];
-      Object expectedElement = expectedElements[i];
-      if (element != expectedElement) {
-        fail("Expected $expectedElement at [$i]; found $element");
-      }
-    }
-  }
-
-  /**
-   * Assert that the given list is non-`null` and has exactly expected elements.
-   *
-   * @param list the list being tested
-   * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the list is `null` or does not have the expected elements
-   */
-  static void assertExactElementsInList(List list,
-      List<Object> expectedElements) {
-    int expectedSize = expectedElements.length;
-    if (list == null) {
-      fail("Expected list of size $expectedSize; found null");
-    }
-    if (list.length != expectedSize) {
-      fail("Expected list of size $expectedSize; contained ${list.length} elements");
-    }
-    for (int i = 0; i < expectedSize; i++) {
-      Object element = list[i];
-      Object expectedElement = expectedElements[i];
-      if (element != expectedElement) {
-        fail("Expected $expectedElement at [$i]; found $element");
-      }
-    }
-  }
-
-  /**
-   * Assert that the given list is non-`null` and has exactly expected elements.
-   *
-   * @param set the list being tested
-   * @param expectedElements the expected elements
-   * @throws AssertionFailedError if the list is `null` or does not have the expected elements
-   */
-  static void assertExactElementsInSet(Set set, List<Object> expectedElements) {
-    int expectedSize = expectedElements.length;
-    if (set == null) {
-      fail("Expected list of size $expectedSize; found null");
-    }
-    if (set.length != expectedSize) {
-      fail("Expected list of size $expectedSize; contained ${set.length} elements");
-    }
-    for (int i = 0; i < expectedSize; i++) {
-      Object expectedElement = expectedElements[i];
-      if (!set.contains(expectedElement)) {
-        fail("Expected $expectedElement in set$set");
-      }
-    }
-  }
-
-  /**
    * 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;
   }
 
   /**
-   * Assert that the actual token has the same type and lexeme as the expected token. Note that this
-   * does not assert anything about the offsets of the tokens (although the lengths will be equal).
-   *
-   * @param expectedToken the token that was expected
-   * @param actualToken the token that was found
-   * @throws AssertionFailedError if the two tokens are not the same
-   */
-  static void assertMatches(Token expectedToken, Token actualToken) {
-    expect(actualToken.type, expectedToken.type);
-    if (expectedToken is KeywordToken) {
-      assertInstanceOf((obj) => obj is KeywordToken, KeywordToken, actualToken);
-      expect((actualToken as KeywordToken).keyword, expectedToken.keyword);
-    } else if (expectedToken is StringToken) {
-      assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
-      expect((actualToken as StringToken).lexeme, expectedToken.lexeme);
-    }
-  }
-
-
-  /**
    * @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 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) {
     if (element == null) {
       for (int i = 0; i < array.length; i++) {
         if (!found[i]) {
           if (array[i] == null) {
             found[i] = true;
             return;
           }
         }
@@ skipping 522 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);
   }
 }