a === b -> identical(a, b)

sdk/lib/core/expect.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.
 
 /**
  * Expect is used for tests that do not want to make use of the
  * Dart unit test library - for example, the core language tests.
  * Third parties are discouraged from using this, and should use
  * the expect() function in the unit test library instead for
  * test assertions.
  */
 class Expect {
   /**
    * Checks whether the expected and actual values are equal (using `==`).
    */
   static void equals(var expected, var actual, [String reason = null]) {
     if (expected == actual) return;
     String msg = _getMessage(reason);
     _fail("Expect.equals(expected: <$expected>, actual: <$actual>$msg) fails.");
   }
 
   /**
    * Checks whether the actual value is a bool and its value is true.
    */
   static void isTrue(var actual, [String reason = null]) {
-    if (actual === true) return;
+    if (_identical(actual, true)) return;
     String msg = _getMessage(reason);
     _fail("Expect.isTrue($actual$msg) fails.");
   }
 
   /**
    * Checks whether the actual value is a bool and its value is false.
    */
   static void isFalse(var actual, [String reason = null]) {
-    if (actual === false) return;
+    if (_identical(actual, false)) return;
     String msg = _getMessage(reason);
     _fail("Expect.isFalse($actual$msg) fails.");
   }
 
   /**
    * Checks whether [actual] is null.
    */
   static void isNull(actual, [String reason = null]) {
-    if (null === actual) return;
+    if (null == actual) return;
     String msg = _getMessage(reason);
     _fail("Expect.isNull(actual: <$actual>$msg) fails.");
   }
 
   /**
    * Checks whether [actual] is not null.
    */
   static void isNotNull(actual, [String reason = null]) {
-    if (null !== actual) return;
+    if (null != actual) return;
     String msg = _getMessage(reason);
     _fail("Expect.isNotNull(actual: <$actual>$msg) fails.");
   }
 
   /**
    * Checks whether the expected and actual values are identical
    * (using `===`).
    */
   static void identical(var expected, var actual, [String reason = null]) {
-    if (expected === actual) return;
+    if (_identical(expected, actual)) return;
     String msg = _getMessage(reason);
     _fail("Expect.identical(expected: <$expected>, actual: <$actual>$msg) "
           "fails.");
   }
 
   // Unconditional failure.
   static void fail(String msg) {
     _fail("Expect.fail('$msg')");
   }
 
   /**
    * Failure if the difference between expected and actual is greater than the
    * given tolerance. If no tolerance is given, tolerance is assumed to be the
    * value 4 significant digits smaller than the value given for expected.
    */
   static void approxEquals(num expected,
                            num actual,
                            [num tolerance = null,
                             String reason = null]) {
-    if (tolerance === null) {
+    if (tolerance == null) {
       tolerance = (expected / 1e4).abs();
     }
     // Note: use !( <= ) rather than > so we fail on NaNs
     if ((expected - actual).abs() <= tolerance) return;
 
     String msg = _getMessage(reason);
     _fail('Expect.approxEquals(expected:<$expected>, actual:<$actual>, '
           'tolerance:<$tolerance>$msg) fails');
   }
 
@@ skipping 58 matching lines @@
    * this method shows where the mismatch starts and ends.
    */
   static void stringEquals(String expected,
                            String actual,
                            [String reason = null]) {
     String msg = _getMessage(reason);
     String defaultMessage =
         'Expect.stringEquals(expected: <$expected>", <$actual>$msg) fails';
 
     if (expected == actual) return;
-    if ((expected === null) || (actual === null)) {
+    if ((expected == null) || (actual == null)) {
       _fail('$defaultMessage');
     }
     // scan from the left until we find a mismatch
     int left = 0;
     int eLen = expected.length;
     int aLen = actual.length;
     while (true) {
       if (left == eLen) {
         assert (left < aLen);
         String snippet = actual.substring(left, aLen);
@@ skipping 85 matching lines @@
    * the type of the exception you could write this:
    *
    *     Expect.throws(myThrowingFunction, (e) => e is MyException);
    */
   static void throws(void f(),
                      [_CheckExceptionFn check = null,
                       String reason = null]) {
     try {
       f();
     } catch (e, s) {
-      if (check !== null) {
+      if (check != null) {
         if (!check(e)) {
           String msg = reason == null ? "" : reason;
           _fail("Expect.throws($msg): Unexpected '$e'\n$s");
         }
       }
       return;
     }
     String msg = reason == null ? "" : reason;
     _fail('Expect.throws($msg) fails');
   }
 
   static String _getMessage(String reason)
-      => (reason === null) ? "" : ", '$reason'";
+      => (reason == null) ? "" : ", '$reason'";
 
   static void _fail(String message) {
     throw new ExpectException(message);
   }
 }
 
+bool _identical(a, b) => identical(a, b);
+
 typedef bool _CheckExceptionFn(exception);
 
 class ExpectException implements Exception {
   ExpectException(this.message);
   String toString() => message;
   String message;
 }