Reapply "Make Map constructors return LinkedHashMap."

Updated tests assuming a specific ordering of an unlinked hash map
to not be daft.

R=floitsch@google.com, jmesserly@google.com

Review URL: https://codereview.chromium.org//22859069

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@26693 260f80e4-7a28-3924-810f-c04153c831b5

pkg/analyzer_experimental/lib/src/generated/java_core.dart

@@ -34,6 +34,9 @@ bool isInstanceOf(o, Type t) {
   if (oTypeName.startsWith("HashMap") && tTypeName == "Map") {
     return true;
   }
+  if (oTypeName.startsWith("LinkedHashMap") && tTypeName == "Map") {
+    return true;
+  }
   if (oTypeName.startsWith("List") && tTypeName == "List") {
     return true;
   }

pkg/csslib/test/var_test.dart

@@ -207,7 +207,7 @@ div {
 }
 
 .test-2 {
-  background: var(color-background) var(image-2, url('img_1.png')) 
+  background: var(color-background) var(image-2, url('img_1.png'))
               no-repeat right top;
 }
 
@@ -322,38 +322,44 @@ void cyclesVar() {
 
   expect(stylesheet != null, true);
   expect(errors.length, 8, reason: errors.toString());
-  expect(errors[0].toString(),
+  int testBitMap = 0;
+  var errorStrings = [
       'error :14:3: var cycle detected var-six\n'
       '  var-six: var(four);\n'
-      '  ^^^^^^^^^^^^^^^^^^');
-  expect(errors[1].toString(),
+      '  ^^^^^^^^^^^^^^^^^^',
       'error :18:3: var cycle detected var-def-3\n'
       '  var-def-3: var(def-2);\n'
-      '  ^^^^^^^^^^^^^^^^^^^^^');
-  expect(errors[2].toString(),
+      '  ^^^^^^^^^^^^^^^^^^^^^',
       'error :10:3: var cycle detected var-two\n'
       '  var-two: var(one);\n'
-      '  ^^^^^^^^^^^^^^^^^');
-  expect(errors[3].toString(),
+      '  ^^^^^^^^^^^^^^^^^',
       'error :17:3: var cycle detected var-def-2\n'
       '  var-def-2: var(def-3);\n'
-      '  ^^^^^^^^^^^^^^^^^^^^^');
-  expect(errors[4].toString(),
+      '  ^^^^^^^^^^^^^^^^^^^^^',
       'error :16:3: var cycle detected var-def-1\n'
       '  var-def-1: var(def-2);\n'
-      '  ^^^^^^^^^^^^^^^^^^^^^');
-  expect(errors[5].toString(),
+      '  ^^^^^^^^^^^^^^^^^^^^^',
       'error :13:3: var cycle detected var-five\n'
       '  var-five: var(six);\n'
-      '  ^^^^^^^^^^^^^^^^^^');
-  expect(errors[6].toString(),
+      '  ^^^^^^^^^^^^^^^^^^',
       'error :9:3: var cycle detected var-one\n'
       '  var-one: var(two);\n'
-      '  ^^^^^^^^^^^^^^^^^');
-  expect(errors[7].toString(),
+      '  ^^^^^^^^^^^^^^^^^',
       'error :12:3: var cycle detected var-four\n'
       '  var-four: var(five);\n'
-      '  ^^^^^^^^^^^^^^^^^^^');
+      '  ^^^^^^^^^^^^^^^^^^^'
+  ];
+  outer: for (var error in errors) {
+    var errorString = error.toString();
+    for (int i = 0; i < 8; i++) {
+      if (errorString == errorStrings[i]) {
+        testBitMap |= 1 << i;
+        continue outer;
+      }
+    }
+    fail("Unexpected error string: $errorString");
+  }
+  expect(testBitMap, equals((1 << 8) - 1));
   expect(prettyPrint(stylesheet), generated);
 }
 

pkg/polymer/test/css_test.dart

@@ -412,64 +412,62 @@ test_component_var() {
         }
       }
 
-      // Check for warning messages about var- cycles.
+      // Check for warning messages about var- cycles in no expected order.
       expect(messages.messages.length, 8);
-
-      var errorMessage = messages.messages[0];
-      expect(errorMessage.message, contains('var cycle detected var-def-1'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 11);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@def-1: var(def-2)');
-
-      errorMessage = messages.messages[1];
-      expect(errorMessage.message, contains('var cycle detected var-five'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 8);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@five: var(six)');
-
-      errorMessage = messages.messages[2];
-      expect(errorMessage.message, contains('var cycle detected var-six'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 9);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@six: var(four)');
-
-      errorMessage = messages.messages[3];
-      expect(errorMessage.message, contains('var cycle detected var-def-3'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 13);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@def-3: var(def-2)');
-
-      errorMessage = messages.messages[4];
-      expect(errorMessage.message, contains('var cycle detected var-two'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 5);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@two: var(one)');
-
-      errorMessage = messages.messages[5];
-      expect(errorMessage.message, contains('var cycle detected var-def-2'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 12);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@def-2: var(def-3)');
-
-      errorMessage = messages.messages[6];
-      expect(errorMessage.message, contains('var cycle detected var-one'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 4);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@one: var(two)');
-
-      errorMessage = messages.messages[7];
-      expect(errorMessage.message, contains('var cycle detected var-four'));
-      expect(errorMessage.span, isNotNull);
-      expect(errorMessage.span.start.line, 7);
-      expect(errorMessage.span.start.column, 22);
-      expect(errorMessage.span.text, '@four: var(five)');
+      int testBitMap = 0;
+      for (var errorMessage in messages.messages) {
+        var message = errorMessage.message;
+        if (message.contains('var cycle detected var-def-1')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 11);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@def-1: var(def-2)');
+          testBitMap |= 1 << 0;
+        } else if (message.contains('var cycle detected var-five')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 8);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@five: var(six)');
+          testBitMap |= 1 << 1;
+        } else if (message.contains('var cycle detected var-six')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 9);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@six: var(four)');
+          testBitMap |= 1 << 2;
+        } else if (message.contains('var cycle detected var-def-3')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 13);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@def-3: var(def-2)');
+          testBitMap |= 1 << 3;
+        } else if (message.contains('var cycle detected var-two')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 5);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@two: var(one)');
+          testBitMap |= 1 << 4;
+        } else if (message.contains('var cycle detected var-def-2')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 12);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@def-2: var(def-3)');
+          testBitMap |= 1 << 5;
+        } else if (message.contains('var cycle detected var-one')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 4);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@one: var(two)');
+          testBitMap |= 1 << 6;
+        } else if (message.contains('var cycle detected var-four')) {
+          expect(errorMessage.span, isNotNull);
+          expect(errorMessage.span.start.line, 7);
+          expect(errorMessage.span.start.column, 22);
+          expect(errorMessage.span.text, '@four: var(five)');
+          testBitMap |= 1 << 7;
+        }
+      }
+      expect(testBitMap, equals((1 << 8) - 1));
     }));
   });
 }

sdk/lib/collection/iterable.dart

@@ -54,7 +54,7 @@ abstract class IterableMixin<E> implements Iterable<E> {
     return true;
   }
 
-  String join([String separator]) {
+  String join([String separator = ""]) {
     Iterator<E> iterator = this.iterator;
     if (!iterator.moveNext()) return "";
     StringBuffer buffer = new StringBuffer();
@@ -245,7 +245,7 @@ abstract class IterableBase<E> implements Iterable<E> {
     return true;
   }
 
-  String join([String separator]) {
+  String join([String separator = ""]) {
     Iterator<E> iterator = this.iterator;
     if (!iterator.moveNext()) return "";
     StringBuffer buffer = new StringBuffer();

sdk/lib/collection/linked_hash_map.dart

@@ -10,7 +10,7 @@ part of dart.collection;
  * Keys insertion order is remembered, and keys are iterated in insertion order.
  * Values are iterated in their corresponding key's order.
  *
- * The keys of a `HashMap` must have consistent [Object.operator==]
+ * The keys of a `LinkedHashMap` must have consistent [Object.operator==]
  * and [Object.hashCode] implementations. This means that the `==` operator
  * must define a stable equivalence relation on the keys (reflexive,
  * anti-symmetric, transitive, and consistent over time), and that `hashCode`
@@ -18,7 +18,7 @@ part of dart.collection;
  *
  * The map allows `null` as a key.
  */
-class LinkedHashMap<K, V> implements Map<K, V> {
+class LinkedHashMap<K, V> implements HashMap<K, V> {
   external LinkedHashMap();
 
   /**

sdk/lib/core/map.dart

@@ -15,12 +15,12 @@ abstract class Map<K, V> {
   /**
    * Creates a Map instance with the default implementation.
    */
-  factory Map() => new HashMap<K, V>();
+  factory Map() = LinkedHashMap<K, V>;
 
   /**
    * Creates a Map instance that contains all key-value pairs of [other].
    */
-  factory Map.from(Map<K, V> other) => new HashMap<K, V>.from(other);
+  factory Map.from(Map<K, V> other) = LinkedHashMap<K, V>.from;
 
   /**
    * Creates a Map instance
@@ -29,7 +29,7 @@ abstract class Map<K, V> {
    * For each element of the [iterable] this constructor computes a key-value
    * pair, by applying [key] and [value] respectively.
    *
-   * The keys computed by the source [iterable] 
+   * The keys computed by the source [iterable]
    * do not need to be unique. The last
    * occurrence of a key will simply overwrite any previous value.
    *
@@ -37,7 +37,7 @@ abstract class Map<K, V> {
    * identity function.
    */
   factory Map.fromIterable(Iterable<K> iterable,
-      {K key(element), V value(element)}) = HashMap<K, V>.fromIterable;
+      {K key(element), V value(element)}) = LinkedHashMap<K, V>.fromIterable;
 
   /**
    * Creates a Map instance associating the given [keys] to [values].
@@ -51,7 +51,7 @@ abstract class Map<K, V> {
    * It is an error if the two [Iterable]s don't have the same length.
    */
   factory Map.fromIterables(Iterable<K> keys, Iterable<V> values)
-      = HashMap<K, V>.fromIterables;
+      = LinkedHashMap<K, V>.fromIterables;
 
   /**
    * Returns true if this map contains the given value.

tests/corelib/linked_hash_map_from_iterable_test.dart

@@ -20,7 +20,6 @@ void defaultFunctionValuesTest() {
 
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -36,7 +35,6 @@ void defaultKeyFunctionTest() {
 
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -52,7 +50,6 @@ void defaultValueFunctionTest() {
 
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -69,7 +66,6 @@ void noDefaultValuesTest() {
 
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -84,7 +80,6 @@ void emptyIterableTest() {
   var map = new LinkedHashMap.fromIterable([]);
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(0, map.length);
   Expect.equals(0, map.keys.length);
@@ -96,7 +91,6 @@ void equalElementsTest() {
 
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(2, map.length);
   Expect.equals(2, map.keys.length);

tests/corelib/linked_hash_map_from_iterables_test.dart

@@ -18,7 +18,6 @@ void positiveTest() {
   var map = new LinkedHashMap.fromIterables([1, 2, 3], ["one", "two", "three"]);
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -33,7 +32,6 @@ void emptyMapTest() {
   var map = new LinkedHashMap.fromIterables([], []);
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(0, map.length);
   Expect.equals(0, map.keys.length);
@@ -52,7 +50,6 @@ void equalElementsTest() {
   var map = new LinkedHashMap.fromIterables([1, 2, 2], ["one", "two", "three"]);
   Expect.isTrue(map is Map);
   Expect.isTrue(map is LinkedHashMap);
-  Expect.isFalse(map is HashMap);
 
   Expect.equals(2, map.length);
   Expect.equals(2, map.keys.length);

tests/corelib/map_from_iterable_test.dart

@@ -19,7 +19,7 @@ void defaultFunctionValuesTest() {
   var map = new Map.fromIterable([1, 2, 3]);
 
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -34,7 +34,7 @@ void defaultKeyFunctionTest() {
   var map = new Map.fromIterable([1, 2, 3], value: (x) => x + 1);
 
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -49,7 +49,7 @@ void defaultValueFunctionTest() {
   var map = new Map.fromIterable([1, 2, 3], key: (x) => x + 1);
 
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -64,9 +64,8 @@ void noDefaultValuesTest() {
   var map = new Map.fromIterable([1, 2, 3],
       key: (x) => x + 1, value: (x) => x - 1);
 
-
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -80,7 +79,7 @@ void noDefaultValuesTest() {
 void emptyIterableTest() {
   var map = new Map.fromIterable([]);
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(0, map.length);
   Expect.equals(0, map.keys.length);
@@ -91,7 +90,7 @@ void equalElementsTest() {
   var map = new Map.fromIterable([1, 2, 2], key: (x) => x + 1);
 
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(2, map.length);
   Expect.equals(2, map.keys.length);

tests/corelib/map_from_iterables_test.dart

@@ -17,7 +17,7 @@ main() {
 void positiveTest() {
   var map = new Map.fromIterables([1, 2, 3], ["one", "two", "three"]);
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(3, map.length);
   Expect.equals(3, map.keys.length);
@@ -31,7 +31,7 @@ void positiveTest() {
 void emptyMapTest() {
   var map = new Map.fromIterables([], []);
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(0, map.length);
   Expect.equals(0, map.keys.length);
@@ -49,7 +49,7 @@ void fewerKeysIterableTest() {
 void equalElementsTest() {
   var map = new Map.fromIterables([1, 2, 2], ["one", "two", "three"]);
   Expect.isTrue(map is Map);
-  Expect.isTrue(map is HashMap);
+  Expect.isTrue(map is LinkedHashMap);
 
   Expect.equals(2, map.length);
   Expect.equals(2, map.keys.length);

tests/corelib/map_from_test.dart

@@ -9,6 +9,7 @@ import 'dart:collection';
 main() {
   testWithConstMap();
   testWithNonConstMap();
+  testWithHashMap();
   testWithLinkedMap();
 }
 
@@ -17,7 +18,7 @@ testWithConstMap() {
   var otherMap = new Map.from(map);
   Expect.isTrue(otherMap is Map);
   Expect.isTrue(otherMap is HashMap);
-  Expect.isTrue(otherMap is !LinkedHashMap);
+  Expect.isTrue(otherMap is LinkedHashMap);
 
   Expect.equals(2, otherMap.length);
   Expect.equals(2, otherMap.keys.length);
@@ -38,7 +39,7 @@ testWithNonConstMap() {
   var otherMap = new Map.from(map);
   Expect.isTrue(otherMap is Map);
   Expect.isTrue(otherMap is HashMap);
-  Expect.isTrue(otherMap is !LinkedHashMap);
+  Expect.isTrue(otherMap is LinkedHashMap);
 
   Expect.equals(2, otherMap.length);
   Expect.equals(2, otherMap.keys.length);
@@ -68,11 +69,23 @@ testWithNonConstMap() {
   Expect.equals(3, otherMap.values.length);
 }
 
+testWithHashMap() {
+  var map = const { 'b': 1, 'a': 2, 'c': 3 };
+  var otherMap = new HashMap.from(map);
+  Expect.isTrue(otherMap is Map);
+  Expect.isTrue(otherMap is HashMap);
+  Expect.isTrue(otherMap is !LinkedHashMap);
+  var i = 1;
+  for (var val in map.values) {
+    Expect.equals(i++, val);
+  }
+}
+
 testWithLinkedMap() {
   var map = const { 'b': 1, 'a': 2, 'c': 3 };
   var otherMap = new LinkedHashMap.from(map);
   Expect.isTrue(otherMap is Map);
-  Expect.isTrue(otherMap is! HashMap);
+  Expect.isTrue(otherMap is HashMap);
   Expect.isTrue(otherMap is LinkedHashMap);
   var i = 1;
   for (var val in map.values) {

tests/corelib/map_values2_test.dart

@@ -42,9 +42,9 @@ main() {
   Expect.isFalse(map5.values is Iterable<bool>);
   Expect.isFalse(map5.values is List);
   Expect.equals(2, map5.values.length);
-  Expect.isTrue(map5.values.first == 43 || map5.values.first == 500);
-  Expect.isTrue(map5.values.last == 43 || map5.values.first == 500);
-  Expect.notEquals(map5.values.first, map5.values.last);
+  // new Map gives a LinkedHashMap, so we know the order.
+  Expect.isTrue(map5.values.first == 43);
+  Expect.isTrue(map5.values.last == 500);
 
   Expect.isTrue(map6.values is Iterable<int>);
   Expect.isFalse(map6.values is Iterable<bool>);

tests/standalone/io/http_detach_socket_test.dart

@@ -78,12 +78,15 @@ void testClientDetachSocket() {
       socket.listen(
         (data) => body.write(new String.fromCharCodes(data)),
         onDone: () {
-          Expect.equals("GET / HTTP/1.1\r\n"
-                        "accept-encoding: gzip\r\n"
-                        "content-length: 0\r\n"
-                        "host: 127.0.0.1:${server.port}\r\n\r\n"
-                        "Some data",
-                        body.toString());
+          List<String> lines = body.toString().split("\r\n");
+          Expect.equals(6, lines.length);
+          Expect.equals("GET / HTTP/1.1", lines[0]);
+          Expect.equals("", lines[4]);
+          Expect.equals("Some data", lines[5]);
+          lines.sort();  // Lines 1-3 becomes 3-5 in a fixed order.
+          Expect.equals("accept-encoding: gzip", lines[3]);
+          Expect.equals("content-length: 0", lines[4]);
+          Expect.equals("host: 127.0.0.1:${server.port}", lines[5]);
           socket.close();
         });
       server.close();