src/v8/test/mjsunit/math-round.js

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 // Flags: --allow-natives-syntax
  29
  30 var test_id = 0;
  31 function testRound(expect, input) {
  32   // Make source code different on each invocation to make
  33   // sure it gets optimized each time.
  34   var doRound = new Function('input',
  35                              '"' + (test_id++) + '";return Math.round(input)');
  36   assertEquals(expect, doRound(input));
  37   assertEquals(expect, doRound(input));
  38   assertEquals(expect, doRound(input));
  39   %OptimizeFunctionOnNextCall(doRound);
  40   assertEquals(expect, doRound(input));
  41
  42   // Force the Math.round() representation to double to exercise the associated
  43   // optimized code.
  44   var doRoundToDouble = new Function('input',
  45                                      '"' + (test_id++) + '";return Math.round(input) + -0.0');
  46   assertEquals(expect, doRoundToDouble(input));
  47   assertEquals(expect, doRoundToDouble(input));
  48   assertEquals(expect, doRoundToDouble(input));
  49   %OptimizeFunctionOnNextCall(doRoundToDouble);
  50   assertEquals(expect, doRoundToDouble(input));
  51 }
  52
  53 testRound(0, 0);
  54 testRound(-0, -0);
  55 testRound(Infinity, Infinity);
  56 testRound(-Infinity, -Infinity);
  57 testRound(NaN, NaN);
  58
  59 // Regression test for a bug where a negative zero coming from Math.round
  60 // was not properly handled by other operations.
  61 function roundsum(i, n) {
  62   var ret = Math.round(n);
  63   while (--i > 0) {
  64     ret += Math.round(n);
  65   }
  66   return ret;
  67 }
  68 assertEquals(-0, roundsum(1, -0));
  69 %OptimizeFunctionOnNextCall(roundsum);
  70 // The optimized function will deopt.  Run it with enough iterations to try
  71 // to optimize via OSR (triggering the bug).
  72 assertEquals(-0, roundsum(100000, -0));
  73
  74 testRound(1, 0.5);
  75 testRound(1, 0.7);
  76 testRound(1, 1);
  77 testRound(1, 1.1);
  78 testRound(1, 1.49999);
  79 testRound(-0, -0.5);
  80 testRound(-1, -0.5000000000000001);
  81 testRound(-1, -0.7);
  82 testRound(-1, -1);
  83 testRound(-1, -1.1);
  84 testRound(-1, -1.49999);
  85 testRound(-1, -1.5);
  86
  87 testRound(9007199254740990, 9007199254740990);
  88 testRound(9007199254740991, 9007199254740991);
  89 testRound(-9007199254740990, -9007199254740990);
  90 testRound(-9007199254740991, -9007199254740991);
  91 testRound(Number.MAX_VALUE, Number.MAX_VALUE);
  92 testRound(-Number.MAX_VALUE, -Number.MAX_VALUE);
  93 testRound(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER);
  94 testRound(Number.MAX_SAFE_INTEGER + 1, Number.MAX_SAFE_INTEGER + 1);
  95 testRound(Number.MAX_SAFE_INTEGER + 2, Number.MAX_SAFE_INTEGER + 2);
  96 testRound(Number.MAX_SAFE_INTEGER + 3, Number.MAX_SAFE_INTEGER + 3);
  97 testRound(Number.MAX_SAFE_INTEGER + 4, Number.MAX_SAFE_INTEGER + 4);
  98 testRound(Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER);
  99 testRound(Number.MIN_SAFE_INTEGER - 1, Number.MIN_SAFE_INTEGER - 1);
 100 testRound(Number.MIN_SAFE_INTEGER - 2, Number.MIN_SAFE_INTEGER - 2);
 101 testRound(Number.MIN_SAFE_INTEGER - 3, Number.MIN_SAFE_INTEGER - 3);
 102
 103 testRound(536870911, 536870910.5);
 104 testRound(536870911, 536870911);
 105 testRound(536870911, 536870911.4);
 106 testRound(536870912, 536870911.5);
 107 testRound(536870912, 536870912);
 108 testRound(536870912, 536870912.4);
 109 testRound(536870913, 536870912.5);
 110 testRound(536870913, 536870913);
 111 testRound(536870913, 536870913.4);
 112 testRound(1073741823, 1073741822.5);
 113 testRound(1073741823, 1073741823);
 114 testRound(1073741823, 1073741823.4);
 115 testRound(1073741824, 1073741823.5);
 116 testRound(1073741824, 1073741824);
 117 testRound(1073741824, 1073741824.4);
 118 testRound(1073741825, 1073741824.5);
 119 testRound(2147483647, 2147483646.5);
 120 testRound(2147483647, 2147483647);
 121 testRound(2147483647, 2147483647.4);
 122 testRound(2147483648, 2147483647.5);
 123 testRound(2147483648, 2147483648);
 124 testRound(2147483648, 2147483648.4);
 125 testRound(2147483649, 2147483648.5);
 126
 127 // Tests based on WebKit LayoutTests
 128
 129 testRound(0, 0.4);
 130 testRound(-0, -0.4);
 131 testRound(-0, -0.5);
 132 testRound(1, 0.6);
 133 testRound(-1, -0.6);
 134 testRound(2, 1.5);
 135 testRound(2, 1.6);
 136 testRound(-2, -1.6);
 137 testRound(8640000000000000, 8640000000000000);
 138 testRound(8640000000000001, 8640000000000001);
 139 testRound(8640000000000002, 8640000000000002);
 140 testRound(9007199254740990, 9007199254740990);
 141 testRound(9007199254740991, 9007199254740991);
 142 testRound(1.7976931348623157e+308, 1.7976931348623157e+308);
 143 testRound(-8640000000000000, -8640000000000000);
 144 testRound(-8640000000000001, -8640000000000001);
 145 testRound(-8640000000000002, -8640000000000002);
 146 testRound(-9007199254740990, -9007199254740990);
 147 testRound(-9007199254740991, -9007199254740991);
 148 testRound(-1.7976931348623157e+308, -1.7976931348623157e+308);
 149 testRound(Infinity, Infinity);
 150 testRound(-Infinity, -Infinity);
 151
 152   // Some special double number cases.
 153 var ulp = Math.pow(2, -1022 - 52);
 154 var max_denormal = (Math.pow(2, 52) - 1) * ulp;
 155 var min_normal = Math.pow(2, -1022);
 156 var max_fraction = Math.pow(2, 52) - 0.5;
 157 var min_nonfraction = Math.pow(2, 52);
 158 var max_non_infinite = Number.MAX_VALUE;
 159
 160 var max_smi31 = Math.pow(2,30) - 1;
 161 var min_smi31 = -Math.pow(2,30);
 162 var max_smi32 = Math.pow(2,31) - 1;
 163 var min_smi32 = -Math.pow(2,31);
 164
 165 testRound(0, ulp);
 166 testRound(0, max_denormal);
 167 testRound(0, min_normal);
 168 testRound(0, 0.49999999999999994);
 169 testRound(1, 0.5);
 170 testRound(Math.pow(2,52), max_fraction);
 171 testRound(min_nonfraction, min_nonfraction);
 172 testRound(max_non_infinite, max_non_infinite);
 173
 174 testRound(max_smi31, max_smi31 - 0.5);
 175 testRound(max_smi31 + 1, max_smi31 + 0.5);
 176 testRound(max_smi32, max_smi32 - 0.5);
 177 testRound(max_smi32 + 1, max_smi32 + 0.5);
 178
 179 testRound(-0, -ulp);
 180 testRound(-0, -max_denormal);
 181 testRound(-0, -min_normal);
 182 testRound(-0, -0.49999999999999994);
 183 testRound(-0, -0.5);
 184 testRound(-Math.pow(2,52)+1, -max_fraction);
 185 testRound(-min_nonfraction, -min_nonfraction);
 186 testRound(-max_non_infinite, -max_non_infinite);
 187
 188 testRound(min_smi31, min_smi31 - 0.5);
 189 testRound(min_smi31 + 1, min_smi31 + 0.5);
 190 testRound(min_smi32, min_smi32 - 0.5);
 191 testRound(min_smi32 + 1, min_smi32 + 0.5);