anchor.diff:  // local x.hashCode calls might be optimized.
   var hash = new Hasher().hash;
   
  -check(value1, value2) {
  +check(value1, value2, {identityHashCode}) {
     var h1 = hash(value1);
     var h2 = hash(value2);
  -
     Expect.isTrue(h1 is int);
     Expect.isTrue(h2 is int);
  -  Expect.isFalse(h1 == h2);
  -
  -  // We expect that the hash function is reasonable quality - there are some
  -  // difference in the low bits.
  -  Expect.isFalse((h1 & 0xf) == (h2 & 0xf));
   
     // Quality check - the values should be SMIs for efficient arithmetic.
     Expect.equals((h1 & 0x3fffffff), h1);
     Expect.equals((h2 & 0x3fffffff), h2);
  +
  +  // If we're checking the (randomized) identity hash code function,
  +  // we cannot guarantee anything about the actual hash code values.
  +  if (identityHashCode) return;
  +
  +  // We expect that the hash function is reasonable quality - there
  +  // are some difference in the low bits.
  +  Expect.isFalse(h1 == h2);
  +  Expect.isFalse((h1 & 0xf) == (h2 & 0xf));
   }
   
   bools() {
  -  check(true, false);
  +  check(true, false, identityHashCode: false);
   
     Expect.equals(true.hashCode, hash(true));   // First can be optimized.
     Expect.equals(false.hashCode, hash(false));
  
positive.code:   var str1 = 'a';
    var str2 = 'b';
    var str3 = 'c';
    check(str1, str2);
    check(str1, str3);
    check(str2, str3);
  
    Expect.equals(str1.hashCode, hash(str1));
    Expect.equals(str2.hashCode, hash(str2));
  
negative.code: lists() {
    var list1 = [];
    var list2 = [];
    check(list1, list2, identityHashCode: true);
  
    Expect.equals(list1.hashCode, hash(list1));
    Expect.equals(list2.hashCode, hash(list2));
  