Add Set.lookup method to get the instance in the set.

tests/corelib/hash_set_test.dart

 // Copyright (c) 2013, 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 of hash set behavior, with focus in iteration and concurrent
 // modification errors.
 
 library hash_map2_test;
 import "package:expect/expect.dart";
 import 'dart:collection';
@@ skipping 200 matching lines @@
     Expect.equals(2, set.length);
     Expect.isTrue(set.contains(1));
     Expect.isFalse(set.contains(2));
     Expect.isTrue(set.contains(3));
     set.retainWhere((each) => each == 3);
     Expect.equals(1, set.length);
     Expect.isFalse(set.contains(1));
     Expect.isFalse(set.contains(2));
     Expect.isTrue(set.contains(3));
   }
+
+  {  // Test lookup
+    Set set = newSet();
+    var m1a = new Mutable(1);
+    var m1b = new Mutable(1);
+    var m2a = new Mutable(2);
+    var m2b = new Mutable(2);
+    Expect.isNull(set.lookup(m1a));
+    Expect.isNull(set.lookup(m1b));
+    set.add(m1a);
+    Expect.identical(m1a, set.lookup(m1a));
+    Expect.identical(m1a, set.lookup(m1b));
+
+    Expect.isNull(set.lookup(m2a));
+    Expect.isNull(set.lookup(m2b));
+    set.add(m2a);
+    Expect.identical(m2a, set.lookup(m2a));
+    Expect.identical(m2a, set.lookup(m2b));
+
+    set.add(m2b);  // Adding doesn't change element.
+    Expect.identical(m2a, set.lookup(m2a));
+    Expect.identical(m2a, set.lookup(m2b));
+
+    set.remove(m1a);
+    set.add(m1b);
+    Expect.identical(m1b, set.lookup(m1a));
+    Expect.identical(m1b, set.lookup(m1b));
+
+    set.add(1);
+    Expect.identical(1, set.lookup(1.0));
+    set.add(-0.0);
+    Expect.identical(-0.0, set.lookup(0.0));
+  }
 }
 
 
 void testIdentitySet(Set create()) {
   Set set = create();
   set.add(1);
   set.add(2);
   set.add(1);  // Integers are identical if equal.
   Expect.equals(2, set.length);
   var complex = 4;
@@ skipping 21 matching lines @@
   Expect.equals(4, set.length);
   Expect.equals(3, m3.hashCode);
   m3.id = 1;
   Expect.equals(1, m3.hashCode);
   // Changing hashCode doesn't affect lookup.
   Expect.isTrue(set.contains(m3));
   Expect.isTrue(set.contains(m1));
   set.remove(m3);
   Expect.isFalse(set.contains(m3));
   Expect.isTrue(set.contains(m1));
+
+  Expect.identical(m1, set.lookup(m1));
+  Expect.identical(null, set.lookup(m3));
 }
 
 
 void main() {
   testSet(() => new Set(), (m) => new Set.from(m));
   testSet(() => new HashSet(), (m) => new HashSet.from(m));
   testSet(() => new LinkedHashSet(), (m) => new LinkedHashSet.from(m));
   testIdentitySet(() => new Set.identity());
   testIdentitySet(() => new HashSet.identity());
   testIdentitySet(() => new LinkedHashSet.identity());
@@ skipping 14 matching lines @@
   // Can't make a bad compareTo that isn't invalid.
   int compareTo(BadHashCode other) => id - other.id;
 }
 
 class Mutable {
   int id;
   Mutable(this.id);
   int get hashCode => id;
   bool operator==(other) => other is Mutable && id == other.id;
 }