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)`.
-    Expect.identical(pow(Infinity, d), pow(-Infinity, d));
-    Expect.identical(pow(0.0, d), pow(-0.0, d));
+    Expect.equals(pow(Infinity, d), pow(-Infinity, d));
+    Expect.equals(pow(0.0, d), pow(-0.0, d));

[Lasse Reichstein Nielsen, 2016/08/12 23:52:38]

I'm not sure that's what we want.

If the problem is with different payload NaNs not being identical, then they are
probably not equal either (since NaN isn't even equal to itself).

According to https://api.dartlang.org/stable/1.18.1/dart-math/pow.html, we only
get NaN for a NaN input or pow(finite-negative, non-integer) so these tests
shouldn't be affected at all.

[Florian Schneider, 2016/08/13 00:01:29]

Never mind my first attempt: Can't use == on NaN in any case.

I can only check that both sides are NaN or not, but I don't want to rely on a
specific bit pattern.

   }
 
   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));
+    Expect.equals(1/pow(d, Infinity), pow(d, -Infinity));

[Lasse Reichstein Nielsen, 2016/08/12 23:52:38]

Again, this should hold, and if it doesn't because of different payload NaNs,
equals shouldn't work either.

   }
 
   // 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();
-}
+}