Remove uses of IterableMixinWorkaround outside of VM and dart2js lists.

tests/corelib/collection_to_string_test.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Tests for the toString methods on collections and maps.
  */
 
 library collection_to_string;
 
 import "package:expect/expect.dart";
 import 'dart:collection' show Queue, LinkedHashMap;
 import 'dart:math' as Math;
 
 // TODO(jjb): seed random number generator when API allows it
 
 const int NUM_TESTS = 300;
 const int MAX_COLLECTION_SIZE = 7;
 
 Math.Random rand;
 
 main() {
   rand = new Math.Random();
   smokeTest();
   exactTest();
-  inexactTest();
 }
 
 
 /**
  * Test a few simple examples.
  */
 void smokeTest() {
   // Non-const lists
   Expect.equals([].toString(), '[]');
   Expect.equals([1].toString(), '[1]');
@@ skipping 42 matching lines @@
  * orders (i.e., no HashSet, HashMap).
  */
 void exactTest() {
   for (int i = 0; i < NUM_TESTS; i++) {
     // Choose a size from 0 to MAX_COLLECTION_SIZE, favoring larger sizes
     int size =
         Math.sqrt(random(MAX_COLLECTION_SIZE * MAX_COLLECTION_SIZE)).toInt();
 
     StringBuffer stringRep = new StringBuffer();
     Object o = randomCollection(size, stringRep, exact:true);
-    print(stringRep);
-    print(o);
-    Expect.equals(o.toString(), stringRep.toString());
+    String expected = stringRep.toString();
+    String actual = o.toString();
+    print("Expect: $expected");

[Søren Gjesse, 2014/05/23 07:18:13]

Debug print.

[Lasse Reichstein Nielsen, 2014/05/23 09:09:53]

Not really, they were already in the test, I just added "Expect:" and "Actual"
in front.

+    print("Actual: $actual");
+    Expect.equals(expected, actual);
   }
 }
 
-/**
- * Generate a bunch of random collections (including Maps), and test that
- * there string form is as expected. The collections include collections
- * as elements, keys, and values, and include recursive references.
- *
- * This test includes collections with ill-defined iteration orders (i.e.,
- * HashSet, HashMap). As a consequence, it can't use equality tests on the
- * string form. Instead, it performs equality tests on their "alphagrams."
- * This might allow false positives, but it does give a fair amount of
- * confidence.
- */
-void inexactTest() {
-  for (int i = 0; i < NUM_TESTS; i++) {
-    // Choose a size from 0 to MAX_COLLECTION_SIZE, favoring larger sizes
-    int size =
-        Math.sqrt(random(MAX_COLLECTION_SIZE * MAX_COLLECTION_SIZE)).toInt();
-
-    StringBuffer stringRep = new StringBuffer();
-    Object o = randomCollection(size, stringRep, exact:false);
-    print(stringRep);
-    print(o);
-    Expect.equals(alphagram(o.toString()), alphagram(stringRep.toString()));
-  }
-}
-
 /**
  * Return a random collection (or Map) of the specified size, placing its
  * string representation into the given string buffer.
  *
  * If exact is true, the returned collections will not be, and will not contain
  * a collection with ill-defined iteration order (i.e., a HashSet or HashMap).
  */
 Object randomCollection(int size, StringBuffer stringRep, {bool exact}) {
   return randomCollectionHelper(size, exact, stringRep, []);
 }
 
 /**
  * Return a random collection (or map) of the specified size, placing its
  * string representation into the given string buffer. The beingMade
  * parameter is a list of collections currently under construction, i.e.,
  * candidates for recursive references.
  *
  * If exact is true, the returned collections will not be, and will not contain
  * a collection with ill-defined iteration order (i.e., a HashSet or HashMap).
  */
 Object randomCollectionHelper(int size, bool exact, StringBuffer stringRep,
-    List beingMade) {
+                              List beingMade) {
   double interfaceFrac = rand.nextDouble();
 
   if (exact) {
     if (interfaceFrac < 1/3) {
       return randomList(size, exact, stringRep, beingMade);
     } else if (interfaceFrac < 2/3) {
       return randomQueue(size, exact, stringRep, beingMade);
     } else {
       return randomMap(size, exact, stringRep, beingMade);
     }
@@ skipping 29 matching lines @@
 Queue randomQueue(int size, bool exact, StringBuffer stringRep, List beingMade){
   return populateRandomCollection(
       size, exact, stringRep, beingMade, new Queue(), "{}");
 }
 
 /**
  * Like randomList, but returns a Set.
  */
 Set randomSet(int size, bool exact, StringBuffer stringRep, List beingMade) {
   // Until we have LinkedHashSet, method will only be called with exact==true
-  return populateRandomSet(size, exact, stringRep, beingMade, new Set());
+  return populateRandomCollection(
+      size, exact, stringRep, beingMade, new Set(), "{}");
 }
 
 /**
  * Like randomList, but returns a map.
  */
 Map randomMap(int size, bool exact, StringBuffer stringRep, List beingMade) {
   if (exact) {
     return populateRandomMap(size, exact, stringRep, beingMade,
         new LinkedHashMap());
   } else {
     return populateRandomMap(size, exact, stringRep, beingMade,
         randomBool() ? new Map() : new LinkedHashMap());
   }
 }
 
 /**
  * Populates the given empty collection with elements, emitting the string
  * representation of the collection to stringRep.  The beingMade parameter is
  * a list of collections currently under construction, i.e., candidates for
  * recursive references.
  *
  * If exact is true, the elements of the returned collections will not be,
- * and will not contain a collection with ill-defined iteration order
+ * and will not contain, a collection with undefined iteration order
  * (i.e., a HashSet or HashMap).
  */
 populateRandomCollection(int size, bool exact,
     StringBuffer stringRep, List beingMade, var coll, String delimiters) {
   beingMade.add(coll);
   int start = stringRep.length;
 
   stringRep.write(delimiters[0]);
 
   List indices = [];
   for (int i = 0; i < size; i++) {
     indices.add(stringRep.length);
     if (i != 0) stringRep.write(', ');
     coll.add(randomElement(random(size), exact, stringRep, beingMade));
   }
-  if (size > 5 && delimiters == "()") {
+  if (size > 5 && coll is! Map
+      // Lists don't yet use ListMixin or its toString.
+      // Remove this line when they do.
+          && coll is! List          /// 01: ok
+     ) {
     const int MAX_LENGTH = 80;
     const int MIN_COUNT = 3;
     const int MAX_COUNT = 100;
-    // It's an iterable, it may omit some elements.
+    // It may omit some elements.
     int end = stringRep.length;
     if (size > MAX_COUNT) {
-      // Last two elements are also omitted, just find the first three or
-      // first 60 characters.
+      // Last two elements are also omitted, just find the first three elements
+      // or first 60 characters.
       for (int i = MIN_COUNT; i < size; i++) {
         int startIndex = indices[i];
         if (startIndex - start > MAX_LENGTH - 6) {  // Limit - ", ...)".length.
           String prefix = stringRep.toString().substring(0, startIndex);
           stringRep.clear();
           stringRep.write(prefix);
           stringRep.write(", ...");
         }
       }
     } else if (stringRep.length - start > MAX_LENGTH - 1) {  // 80 - ")".length.
       // Last two elements are always included. Middle ones may be omitted.
       int lastTwoLength = end - indices[indices.length - 2];
       // Try to find first element to omit.
       for (int i = 3; i <= size - 3; i++) {
         int elementEnd = indices[i + 1];
         int lengthAfter = elementEnd - start;
         int ellipsisSize = 5;  // ", ...".length
         if (i == size - 3) ellipsisSize = 0;  // No ellipsis if we hit the end.
         if (lengthAfter + ellipsisSize + lastTwoLength > MAX_LENGTH - 1) {
           // Omit this element and everything up to the last two.
           int elementStart = indices[i];
+          if (elementStart + ellipsisSize + lastTwoLength >= stringRep.length) {
+            break;
+          }
           // Rewrite string buffer by copying it out, clearing, and putting
           // the parts back in.
           String buffer = stringRep.toString();
           String prefix = buffer.substring(0, elementStart);
           String suffix = buffer.substring(end - lastTwoLength, end);
           stringRep.clear();
           stringRep.write(prefix);
           stringRep.write(", ...");
           stringRep.write(suffix);
           break;
         }
       }
     }
   }
 
   stringRep.write(delimiters[1]);
   beingMade.removeLast();
   return coll;
 }
 
-/** Like populateRandomCollection, but for sets (elements must be hashable) */
-Set populateRandomSet(int size, bool exact, StringBuffer stringRep,
-    List beingMade, Set set) {
-  stringRep.write('{');
-
-  for (int i = 0; i < size; i++) {
-    if (i != 0) stringRep.write(', ');
-    set.add(i);
-    stringRep.write(i);
-  }
-
-  stringRep.write('}');
-  return set;
-}
-
-
 /** Like populateRandomCollection, but for maps. */
 Map populateRandomMap(int size, bool exact, StringBuffer stringRep,
     List beingMade, Map map) {
   beingMade.add(map);
   stringRep.write('{');
 
   for (int i = 0; i < size; i++) {
     if (i != 0) stringRep.write(', ');
 
     int key = i; // Ensures no duplicates
@@ skipping 17 matching lines @@
  * a collection with ill-defined iteration order (i.e., a HashSet or HashMap).
  */
 Object randomElement(int size, bool exact, StringBuffer stringRep,
     List beingMade) {
   Object result;
   double elementTypeFrac = rand.nextDouble();
   if (elementTypeFrac < 1/3) {
     result = random(1000);
     stringRep.write(result);
   } else if (elementTypeFrac < 2/3) {
-    // Element Is a random (new) collection
+    // Element is a random (new) collection
     result = randomCollectionHelper(size, exact, stringRep, beingMade);
   } else {
-    // Element Is a random recursive ref
+    // Element is a random recursive ref
     result = beingMade[random(beingMade.length)];
     if (result is List) {
       stringRep.write('[...]');
     } else if (result is Set || result is Map || result is Queue) {
       stringRep.write('{...}');
     } else {
       stringRep.write('(...)');
     }
   }
   return result;
 }
 
 /** Returns a random int on [0, max) */
 int random(int max) {
   return rand.nextInt(max);
 }
 
 /** Returns a random boolean value. */
 bool randomBool() {
   return rand.nextBool();
 }
-
-/** Returns the alphabetized characters in a string. */
-String alphagram(String s) {
-  // Calling [toList] to convert unmodifiable list to normal list.
-  List<int> chars = s.codeUnits.toList();
-  chars.sort((int a, int b) => a - b);
-  return new String.fromCharCodes(chars);
-}