Fix a test to not expect NaNs to be bitwise identical.

tests/lib/math/double_pow_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.
 // VMOptions=--optimization-counter-threshold=5 --no-background-compilation
 
 library math_test;
 import "package:expect/expect.dart";
 import 'dart:math';
 
 void checkVeryClose(double a, double b) {
@@ skipping 99 matching lines @@
       if (d == dint && dint.isOdd) {
         // if `x` is -Infinity or -0.0 and `y` is an odd integer, then the
         // result is`-pow(-x ,y)`.
         Expect.identical(-pow(Infinity, d), pow(-Infinity, d));
         Expect.identical(-pow(0.0, d), pow(-0.0, d));
         continue;
       }
     }
     // if `x` is -Infinity or -0.0 and `y` is not an odd integer, then the
     // result is the same as `pow(-x , y)`.
+    if (d.isNaN) {
+      Expect.isTrue(pow(Infinity, d).isNaN);
+      Expect.isTrue(pow(-Infinity, d).isNaN);
+      Expect.isTrue(pow(0.0, d).isNaN);
+      Expect.isTrue(pow(-0.0, d).isNaN);
+      continue;
+    }
     Expect.identical(pow(Infinity, d), pow(-Infinity, d));
     Expect.identical(pow(0.0, d), pow(-0.0, d));
   }
 
   for (var d in samples) {
 
     if (d.abs() < 1) {
       // if `y` is Infinity and the absolute value of `x` is less than 1, the
       // result is 0.0.
       Expect.identical(0.0, pow(d, Infinity));
     } else if (d.abs() > 1) {
       // if `y` is Infinity and the absolute value of `x` is greater than 1,
       // the result is Infinity.
       Expect.identical(Infinity, pow(d, Infinity));
     } else if (d == -1) {
       // if `y` is Infinity and `x` is -1, the result is 1.0.
       Expect.identical(1.0, pow(d, Infinity));
     }
     // if `y` is -Infinity, the result is `1/pow(x, Infinity)`.
-    Expect.identical(1/pow(d, Infinity), pow(d, -Infinity));
+    if (d.isNaN) {
+      Expect.isTrue((1/pow(d, Infinity)).isNaN);
+      Expect.isTrue(pow(d, -Infinity).isNaN);
+    } else {
+      Expect.identical(1/pow(d, Infinity), pow(d, -Infinity));
+    }
   }
 
   // Some non-exceptional values.
   checkVeryClose(16.0, pow(4.0, 2.0));
   checkVeryClose(SQRT2, pow(2.0, 0.5));
   checkVeryClose(SQRT1_2, pow(0.5, 0.5));
   // Denormal result.
   Expect.identical(5e-324, pow(2.0, -1074.0));
   // Overflow.
   Expect.identical(Infinity, pow(10.0, 309.0));
   // Underflow.
   Expect.identical(0.0, pow(10.0, -325.0));
 
   // Conversion to double.
 
   // The second argument is an odd integer as int, but not when converted
   // to double.
   Expect.identical(Infinity, pow(-0.0, -9223372036854775809));
 }
 
 main() {
   for (int i = 0; i < 10; i++) test();
-}
+}