Inline JUnitTestCase 'assert' 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/java_junit.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 extends JUnitTestCase {
+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
    * @param names the names
    */
   void assertNamedElements(List<Element> elements, List<String> names) {
     for (String elemName in names) {
       bool found = false;
       for (Element elem in elements) {
         if (elem.name == elemName) {
           found = true;
           break;
         }
       }
       if (!found) {
         StringBuffer buffer = new StringBuffer();
         buffer.write("Expected element named: ");
         buffer.write(elemName);
         buffer.write("\n  but found: ");
         for (Element elem in elements) {
           buffer.write(elem.name);
           buffer.write(", ");
         }
-        JUnitTestCase.fail(buffer.toString());
+        fail(buffer.toString());
       }
     }
     assertLength(names.length, elements);
   }
 
   AnalysisContextImpl createAnalysisContext() {
     AnalysisContextImpl context = new AnalysisContextImpl();
     context.sourceFactory = new SourceFactory([]);
     return context;
   }
 
   /**
    * Return the getter in the given type with the given name. Inherited getters are ignored.
    *
    * @param type the type in which the getter is declared
    * @param getterName the name of the getter to be returned
    * @return the property accessor element representing the getter with the given name
    */
   PropertyAccessorElement getGetter(InterfaceType type, String getterName) {
     for (PropertyAccessorElement accessor in type.element.accessors) {
       if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
       }
     }
-    JUnitTestCase.fail(
-        "Could not find getter named $getterName in ${type.displayName}");
+    fail("Could not find getter named $getterName in ${type.displayName}");
     return null;
   }
 
   /**
    * Return the method in the given type with the given name. Inherited methods are ignored.
    *
    * @param type the type in which the method is declared
    * @param methodName the name of the method to be returned
    * @return the method element representing the method with the given name
    */
   MethodElement getMethod(InterfaceType type, String methodName) {
     for (MethodElement method in type.element.methods) {
       if (method.name == methodName) {
         return method;
       }
     }
-    JUnitTestCase.fail(
-        "Could not find method named $methodName in ${type.displayName}");
+    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
@@ skipping 12 matching lines @@
   /**
    * Assert that the given collection is non-`null` and has the expected number of elements.
    *
    * @param expectedSize the expected number of elements
    * @param c the collection being tested
    * @throws AssertionFailedError if the list is `null` or does not have the expected number
    *           of elements
    */
   static void assertCollectionSize(int expectedSize, Iterable c) {
     if (c == null) {
-      JUnitTestCase.fail(
-          "Expected collection of size $expectedSize; found null");
+      fail("Expected collection of size $expectedSize; found null");
     } else if (c.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected collection of size $expectedSize; contained ${c.length} elements");
+      fail("Expected collection of size $expectedSize; contained ${c.length} elements");
     }
   }
 
   /**
    * 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) {
-      JUnitTestCase.fail(
-          "Expected array of length $expectedSize; found null");
+      fail("Expected array of length $expectedSize; found null");
     }
     if (array.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected array of length $expectedSize; contained ${array.length} elements");
+      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) {
-        JUnitTestCase.assertTrueMsg(
-            "Content not as expected: is 'null' expected: $expected",
-            false);
+        expect(false, isTrue, reason: "Content not as expected: is 'null' expected: $expected");

[Brian Wilkerson, 2014/10/27 23:13:29]

Why not just use 'fail'?

[scheglov, 2014/10/28 00:01:06]

The original Java source:

Assert.assertTrue("Content not as expected: is 'null' expected: " + expected,
false);

Fixed.

       } else {
-        JUnitTestCase.assertTrueMsg(
-            "Content not as expected: expected 'null' is: $actual",
-            false);
+        expect(false, isTrue, reason: "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";
-      JUnitTestCase.assertEqualsMsg(message, expected, actual);
+      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) {
-    JUnitTestCase.assertNotNull(actualValues);
+    expect(actualValues, isNotNull);
     int expectedLength = expectedValues.length;
-    JUnitTestCase.assertEquals(expectedLength, actualValues.length);
+    expect(actualValues.length, expectedLength);
     List<bool> found = new List<bool>.filled(expectedLength, false);
     for (int i = 0; i < expectedLength; i++) {
       found[i] = false;
     }
     for (Object actualValue in actualValues) {
       bool wasExpected = false;
       for (int i = 0; i < expectedLength; i++) {
         if (!found[i] && expectedValues[i] == actualValue) {
           found[i] = true;
           wasExpected = true;
           break;
         }
       }
       if (!wasExpected) {
-        JUnitTestCase.fail("The actual value $actualValue was not expected");
+        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) {
-      JUnitTestCase.fail("Expected array of size $expectedSize; found null");
+      fail("Expected array of size $expectedSize; found null");
     }
     if (array.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected array of size $expectedSize; contained ${array.length} elements");
+      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) {
-        JUnitTestCase.fail(
-            "Expected $expectedElement at [$i]; found $element");
+        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) {
-      JUnitTestCase.fail("Expected list of size $expectedSize; found null");
+      fail("Expected list of size $expectedSize; found null");
     }
     if (list.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected list of size $expectedSize; contained ${list.length} elements");
+      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) {
-        JUnitTestCase.fail(
-            "Expected $expectedElement at [$i]; found $element");
+        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) {
-      JUnitTestCase.fail("Expected list of size $expectedSize; found null");
+      fail("Expected list of size $expectedSize; found null");
     }
     if (set.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected list of size $expectedSize; contained ${set.length} elements");
+      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)) {
-        JUnitTestCase.fail("Expected $expectedElement in set$set");
+        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)) {
-      JUnitTestCase.fail(
-          "Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
+      fail("Expected instance of $expectedClass, found ${object == null ? "null" : object.runtimeType}");
     }
     return object;
   }
 
   /**
    * Assert that the given array is non-`null` and has the expected number of elements.
    *
    * @param expectedLength the expected number of elements
    * @param array the array being tested
    * @throws AssertionFailedError if the array is `null` or does not have the expected number
    *           of elements
    */
   static void assertLength(int expectedLength, List<Object> array) {
     if (array == null) {
-      JUnitTestCase.fail(
-          "Expected array of length $expectedLength; found null");
+      fail("Expected array of length $expectedLength; found null");
     } else if (array.length != expectedLength) {
-      JUnitTestCase.fail(
-          "Expected array of length $expectedLength; contained ${array.length} elements");
+      fail("Expected array of length $expectedLength; contained ${array.length} elements");
     }
   }
 
   /**
    * 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) {
-    JUnitTestCase.assertEquals(expectedToken.type, actualToken.type);
+    expect(actualToken.type, expectedToken.type);
     if (expectedToken is KeywordToken) {
       assertInstanceOf((obj) => obj is KeywordToken, KeywordToken, actualToken);
-      JUnitTestCase.assertEquals(
-          expectedToken.keyword,
-          (actualToken as KeywordToken).keyword);
+      expect((actualToken as KeywordToken).keyword, expectedToken.keyword);
     } else if (expectedToken is StringToken) {
       assertInstanceOf((obj) => obj is StringToken, StringToken, actualToken);
-      JUnitTestCase.assertEquals(
-          expectedToken.lexeme,
-          (actualToken as StringToken).lexeme);
+      expect((actualToken as StringToken).lexeme, expectedToken.lexeme);
     }
   }
 
   /**
    * Assert that the given list is non-`null` and has the expected number of elements.
    *
    * @param expectedSize the expected number of elements
    * @param list the list being tested
    * @throws AssertionFailedError if the list is `null` or does not have the expected number
    *           of elements
    */
   static void assertSizeOfList(int expectedSize, List list) {
     if (list == null) {
-      JUnitTestCase.fail("Expected list of size $expectedSize; found null");
+      fail("Expected list of size $expectedSize; found null");
     } else if (list.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected list of size $expectedSize; contained ${list.length} elements");
+      fail("Expected list of size $expectedSize; contained ${list.length} elements");
     }
   }
 
   /**
    * Assert that the given map is non-`null` and has the expected number of elements.
    *
    * @param expectedSize the expected number of elements
    * @param map the map being tested
    * @throws AssertionFailedError if the map is `null` or does not have the expected number of
    *           elements
    */
   static void assertSizeOfMap(int expectedSize, Map map) {
     if (map == null) {
-      JUnitTestCase.fail("Expected map of size $expectedSize; found null");
+      fail("Expected map of size $expectedSize; found null");
     } else if (map.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected map of size $expectedSize; contained ${map.length} elements");
+      fail("Expected map of size $expectedSize; contained ${map.length} elements");
     }
   }
 
   /**
    * Assert that the given set is non-`null` and has the expected number of elements.
    *
    * @param expectedSize the expected number of elements
    * @param set the set being tested
    * @throws AssertionFailedError if the set is `null` or does not have the expected number of
    *           elements
    */
   static void assertSizeOfSet(int expectedSize, Set set) {
     if (set == null) {
-      JUnitTestCase.fail("Expected set of size $expectedSize; found null");
+      fail("Expected set of size $expectedSize; found null");
     } else if (set.length != expectedSize) {
-      JUnitTestCase.fail(
-          "Expected set of size $expectedSize; contained ${set.length} elements");
+      fail("Expected set of size $expectedSize; contained ${set.length} elements");
     }
   }
 
   /**
    * @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) {
@@ skipping 29 matching lines @@
       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");
+      fail("Does not contain null");
     } else {
       for (int i = 0; i < array.length; i++) {
         if (!found[i]) {
           if (element == array[i]) {
             found[i] = true;
             return;
           }
         }
       }
-      JUnitTestCase.fail("Does not contain $element");
+      fail("Does not contain $element");
     }
   }
 }
 
 /**
  * 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 {
   /**
@@ skipping 100 matching lines @@
    * @param expectedErrorCodes the error codes of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
    *           expected
    */
   void assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
     StringBuffer buffer = new StringBuffer();
     //
     // Verify that the expected error codes have a non-empty message.
     //
     for (ErrorCode errorCode in expectedErrorCodes) {
-      JUnitTestCase.assertFalseMsg(
-          "Empty error code message",
-          errorCode.message.isEmpty);
+      expect(errorCode.message.isEmpty, isFalse, reason: "Empty error code message");
     }
     //
     // Compute the expected number of each type of error.
     //
     HashMap<ErrorCode, int> expectedCounts = new HashMap<ErrorCode, int>();
     for (ErrorCode code in expectedErrorCodes) {
       int count = expectedCounts[code];
       if (count == null) {
         count = 1;
       } else {
@@ skipping 58 matching lines @@
       for (int i = 0; i < actualErrors.length; i++) {
         AnalysisError error = actualErrors[i];
         if (i > 0) {
           buffer.write(", ");
         }
         buffer.write(error.offset);
       }
       buffer.write(")");
     });
     if (buffer.length > 0) {
-      JUnitTestCase.fail(buffer.toString());
+      fail(buffer.toString());
     }
   }
 
   /**
    * Assert that the number of errors that have been gathered matches the number of severities that
    * are given and that there are the same number of errors and warnings as specified by the
    * argument. The order in which the errors were gathered is ignored.
    *
    * @param expectedSeverities the severities of the errors that should have been gathered
    * @throws AssertionFailedError if a different number of errors have been gathered than were
@@ skipping 13 matching lines @@
     int actualWarningCount = 0;
     for (AnalysisError error in _errors) {
       if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) {
         actualErrorCount++;
       } else {
         actualWarningCount++;
       }
     }
     if (expectedErrorCount != actualErrorCount ||
         expectedWarningCount != actualWarningCount) {
-      JUnitTestCase.fail(
-          "Expected $expectedErrorCount errors and $expectedWarningCount warnings, found $actualErrorCount errors and $actualWarningCount warnings");
+      fail("Expected $expectedErrorCount errors and $expectedWarningCount warnings, found $actualErrorCount errors and $actualWarningCount warnings");
     }
   }
 
   /**
    * Assert that no errors have been gathered.
    *
    * @throws AssertionFailedError if any errors have been gathered
    */
   void assertNoErrors() {
     assertErrors(_NO_ERRORS);
@@ skipping 139 matching lines @@
             "  %s %s (%d, %d/%d): %s",
             [
                 source == null ? "" : source.shortName,
                 error.errorCode,
                 location.lineNumber,
                 location.columnNumber,
                 error.length,
                 error.message]);
       }
     }
-    JUnitTestCase.fail(buffer.toString());
+    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);
   }
 }