Change the toString method of IterableBase/IterableMixin to show some elements.

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;
 
@@ skipping 63 matching lines @@
  * 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 restricts itself to collections with well-defined iteration
  * 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();
+    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());
   }
 }
 
 /**
  * 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();
+    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).
@@ skipping 83 matching lines @@
  * 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
  * (i.e., a HashSet or HashMap).
  */
 populateRandomCollection(int size, bool exact,
     StringBuffer stringRep, List beingMade, var coll) {
   beingMade.add(coll);
-  stringRep.write(coll is List ? '[' : '{');
+  String delimiters = "()";  // Default for iterables.
+  if (coll is List) {
+    delimiters = "[]";
+  } else if (coll is Set) {
+    delimiters = "{}";
+  }
+  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 == "()") {
+    const int MAX_LENGTH = 80;
+    const int MIN_COUNT = 3;
+    const int MAX_COUNT = 100;
+    print("CHECKING OMISSIONS");

[floitsch, 2013/10/11 09:29:43]

debug print.

[Lasse Reichstein Nielsen, 2013/10/11 20:25:37]

Done.

+    // It's an iterable, it may omit some elements.
+    int end = stringRep.length;
+    if (size > MAX_COUNT) {
+      print("$size>100");

[floitsch, 2013/10/11 09:29:43]

debug print.

[Lasse Reichstein Nielsen, 2013/10/11 20:25:37]

Done.

+      // Last two elements are also omitted, just find the first three 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.add(prefix);
+          stringRep.add(", ...");
+        }
+      }
+    } else if (stringRep.length - start > MAX_LENGTH - 1) {  // 80 - ")".length.
+      print("$size<=100: $indices");

[floitsch, 2013/10/11 09:29:43]

ditto

[Lasse Reichstein Nielsen, 2013/10/11 20:25:37]

Done.

+      // 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];
+          // 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(coll is List ? ']' : '}');
+  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++) {
@@ skipping 42 matching lines @@
   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
     result = randomCollectionHelper(size, exact, stringRep, beingMade);
   } else {
     // Element Is a random recursive ref
     result = beingMade[random(beingMade.length)];
-    if (result is List)
+    if (result is List) {
       stringRep.write('[...]');
-    else
+    } else if (result is Set || result is Map) {
       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);
 }