Change Set.toSet to always return a set with the same behavior.

tests/corelib/set_test.dart

 // Copyright (c) 2011, 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.
 
 library set_test;
 
 
 import 'package:expect/expect.dart';
 import "dart:collection";
 
 void testMain(Set create()) {
   testInts(create);
   testStrings(create);
+  testInts(() => create().toSet());
+  testStrings(() => create().toSet());
 }
 
 void testInts(Set create()) {
   Set set = create();
 
   testLength(0, set);
   Expect.isTrue(set.add(1));
   testLength(1, set);
   Expect.isTrue(set.contains(1));
 
@@ skipping 159 matching lines @@
   }
   for (int i = 10; i < 20; i++) {
     Expect.isFalse(set.contains(i));
   }
 
   // Test Set.clear.
   set.clear();
   testLength(0, set);
   Expect.isTrue(set.add(11));
   testLength(1, set);
+
+  // Test Set.toSet.
+  set.add(1);
+  set.add(21);
+  testLength(3, set);
+  var set2 = set.toSet();
+  testLength(3, set2);
+  Expect.listEquals(set.toList(), set2.toList());
+  set.add(31);
+  testLength(4, set);
+  testLength(3, set2);
+
+  set2 = set.toSet()..clear();
+  testLength(0, set2);
+  Expect.isTrue(set2.add(11));
+  Expect.isTrue(set2.add(1));
+  Expect.isTrue(set2.add(21));
+  Expect.isTrue(set2.add(31));
+  testLength(4, set2);
+  Expect.listEquals(set.toList(), set2.toList());
+
+  set2 = (set.toSet()..clear()).toSet();  // Cloning empty set shouldn't fail.
+  testLength(0, set2);
 }
 
 void testLength(int length, Set set) {
   Expect.equals(length, set.length);
   (length == 0 ? Expect.isTrue : Expect.isFalse)(set.isEmpty);
   (length != 0 ? Expect.isTrue : Expect.isFalse)(set.isNotEmpty);
   if (length == 0) {
     for (var e in set) { Expect.fail("contains element when iterated: $e"); }
   }
   (length == 0 ? Expect.isFalse : Expect.isTrue)(set.iterator.moveNext());
@@ skipping 149 matching lines @@
 bool validKey(Object o) => o is CE;
 final customId = new Map.identity();
 int counter = 0;
 int identityCompare(e1, e2) {
   if (identical(e1, e2)) return 0;
   int i1 = customId.putIfAbsent(e1, () => ++counter);
   int i2 = customId.putIfAbsent(e2, () => ++counter);
   return i1 - i2;
 }
 
+void testIdentity(Set create()) {
+  Set set = create();
+  var e1 = new CE(0);
+  var e2 = new CE(0);
+  Expect.equals(e1, e2);
+  Expect.isFalse(identical(e1, e2));
+
+  testLength(0, set);
+  set.add(e1);
+  testLength(1, set);
+  Expect.isTrue(set.contains(e1));
+  Expect.isFalse(set.contains(e2));
+
+  set.add(e2);
+  testLength(2, set);
+  Expect.isTrue(set.contains(e1));
+  Expect.isTrue(set.contains(e2));
+
+  var set2 = set.toSet();
+  testLength(2, set2);
+  Expect.isTrue(set2.contains(e1));
+  Expect.isTrue(set2.contains(e2));
+}
+
 main() {
   testMain(() => new HashSet());
   testMain(() => new LinkedHashSet());
+  testMain(() => new HashSet.identity());
+  testMain(() => new LinkedHashSet.identity());
   testMain(() => new HashSet(equals: identical));
   testMain(() => new LinkedHashSet(equals: identical));
   testMain(() => new HashSet(equals: (a, b) => a == b,
                              hashCode: (a) => -a.hashCode,
                              isValidKey: (a) => true));
   testMain(() => new LinkedHashSet(
       equals: (a, b) => a == b,
       hashCode: (a) => -a.hashCode,
       isValidKey: (a) => true));
   testMain(() => new SplayTreeSet());
 
+  testIdentity(() => new HashSet.identity());
+  testIdentity(() => new LinkedHashSet.identity());
+  testIdentity(() => new HashSet(equals: identical));
+  testIdentity(() => new LinkedHashSet(equals: identical));
+  testIdentity(() => new SplayTreeSet(identityCompare));
+
   testTypeAnnotations(new HashSet<int>());
   testTypeAnnotations(new LinkedHashSet<int>());
   testTypeAnnotations(new HashSet<int>(equals: identical));
   testTypeAnnotations(new LinkedHashSet<int>(equals: identical));
   testTypeAnnotations(new HashSet<int>(equals: (int a, int b) => a == b,
                                        hashCode: (int a) => a.hashCode,
                                        isValidKey: (a) => a is int));
   testTypeAnnotations(new LinkedHashSet<int>(equals: (int a, int b) => a == b,
                                              hashCode: (int a) => a.hashCode,
                                              isValidKey: (a) => a is int));
   testTypeAnnotations(new SplayTreeSet<int>());
 
   testRetainWhere(([equals, hashCode, validKey, comparator]) =>
       new HashSet(equals: equals, hashCode: hashCode, isValidKey: validKey));
   testRetainWhere(([equals, hashCode, validKey, comparator]) =>
       new LinkedHashSet(equals: equals, hashCode: hashCode,
                         isValidKey: validKey));
   testRetainWhere(([equals, hashCode, validKey, comparator]) =>
       new SplayTreeSet(comparator, validKey));
 
   testDifferenceIntersection(([equals, hashCode, validKey, comparator]) =>
       new HashSet(equals: equals, hashCode: hashCode, isValidKey: validKey));
   testDifferenceIntersection(([equals, hashCode, validKey, comparator]) =>
       new LinkedHashSet(equals: equals, hashCode: hashCode,
                         isValidKey: validKey));
   testDifferenceIntersection(([equals, hashCode, validKey, comparator]) =>
       new SplayTreeSet(comparator, validKey));
-
 }