New analyzer_experimental snapshot.

pkg/analyzer_experimental/test/generated/test_support.dart

 // 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 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
@@ skipping 370 matching lines @@
     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-{@code 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 {@code 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");
+    }
+    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++) {
+      assertContains2(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
    */
   static void assertEqualsIgnoreOrder(List<Object> expectedValues, List<Object> actualValues) {
     JUnitTestCase.assertNotNull(actualValues);
     int expectedLength = expectedValues.length;
     JUnitTestCase.assertEquals(expectedLength, actualValues.length);
@@ skipping 49 matching lines @@
    * @throws AssertionFailedError if the list is {@code null} or does not have the expected elements
    */
   static void assertExactElements(List<Object> list, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (list == null) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; found null");
     }
     if (list.length != expectedSize) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; contained ${list.length} elements");
     }
-    for (int i = 0; i < expectedElements.length; i++) {
+    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}");
       }
     }
   }
 
   /**
    * Assert that the given array is non-{@code null} and has exactly expected elements.
    * @param array the array being tested
    * @param expectedElements the expected elements
    * @throws AssertionFailedError if the array is {@code null} or does not have the expected
    * elements
    */
   static void assertExactElements2(List<Object> array, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (array == null) {
       JUnitTestCase.fail("Expected array of size ${expectedSize}; found null");
     }
     if (array.length != expectedSize) {
       JUnitTestCase.fail("Expected array of size ${expectedSize}; contained ${array.length} elements");
     }
-    for (int i = 0; i < expectedElements.length; i++) {
+    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}");
       }
     }
   }
 
   /**
    * Assert that the given list is non-{@code null} and has exactly expected elements.
    * @param set the list being tested
    * @param expectedElements the expected elements
    * @throws AssertionFailedError if the list is {@code null} or does not have the expected elements
    */
   static void assertExactElements3(Set<Object> set, List<Object> expectedElements) {
     int expectedSize = expectedElements.length;
     if (set == null) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; found null");
     }
     if (set.length != expectedSize) {
       JUnitTestCase.fail("Expected list of size ${expectedSize}; contained ${set.length} elements");
     }
-    for (int i = 0; i < expectedElements.length; i++) {
+    for (int i = 0; i < expectedSize; i++) {
       Object expectedElement = expectedElements[i];
       if (!set.contains(expectedElement)) {
         JUnitTestCase.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
@@ skipping 91 matching lines @@
    * @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();
     for (String line in lines) {
       writer.println(line);
     }
     return writer.toString();
   }
+  static void assertContains2(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");
+    } 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}");
+    }
+  }
 
   /**
    * 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;
@@ skipping 111 matching lines @@
         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");
     }
   }
 }