src/v8/test/mjsunit/number-tostring-small.js

   1 // Copyright 2008 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 // This file is a concatenation of the number-tostring and
  29 // to-precision mjsunit tests where the mjsunit assert code has been
  30 // removed.
  31
  32 // ----------------------------------------------------------------------
  33 // toString
  34 (NaN).toString();
  35 (1/0).toString();
  36 (-1/0).toString();
  37 (0).toString();
  38 (9).toString();
  39 (90).toString();
  40 (90.12).toString();
  41 (0.1).toString();
  42 (0.01).toString();
  43 (0.0123).toString();
  44 (111111111111111111111).toString();
  45 (1111111111111111111111).toString();
  46 (11111111111111111111111).toString();
  47 (0.00001).toString();
  48 (0.000001).toString();
  49 (0.0000001).toString();
  50 (0.00000012).toString();
  51 (0.000000123).toString();
  52 (0.00000001).toString();
  53 (0.000000012).toString();
  54 (0.0000000123).toString();
  55
  56 (-0).toString();
  57 (-9).toString();
  58 (-90).toString();
  59 (-90.12).toString();
  60 (-0.1).toString();
  61 (-0.01).toString();
  62 (-0.0123).toString();
  63 (-111111111111111111111).toString();
  64 (-1111111111111111111111).toString();
  65 (-11111111111111111111111).toString();
  66 (-0.00001).toString();
  67 (-0.000001).toString();
  68 (-0.0000001).toString();
  69 (-0.00000012).toString();
  70 (-0.000000123).toString();
  71 (-0.00000001).toString();
  72 (-0.000000012).toString();
  73 (-0.0000000123).toString();
  74
  75 (NaN).toString(16);
  76 (1/0).toString(16);
  77 (-1/0).toString(16);
  78 (0).toString(16);
  79 (9).toString(16);
  80 (90).toString(16);
  81 (90.12).toString(16);
  82 (0.1).toString(16);
  83 (0.01).toString(16);
  84 (0.0123).toString(16);
  85 (111111111111111111111).toString(16);
  86 (1111111111111111111111).toString(16);
  87 (11111111111111111111111).toString(16);
  88 (0.00001).toString(16);
  89 (0.000001).toString(16);
  90 (0.0000001).toString(16);
  91 (0.00000012).toString(16);
  92 (0.000000123).toString(16);
  93 (0.00000001).toString(16);
  94 (0.000000012).toString(16);
  95 (0.0000000123).toString(16);
  96
  97 (-0).toString(16);
  98 (-9).toString(16);
  99 (-90).toString(16);
 100 (-90.12).toString(16);
 101 (-0.1).toString(16);
 102 (-0.01).toString(16);
 103 (-0.0123).toString(16);
 104 (-111111111111111111111).toString(16);
 105 (-1111111111111111111111).toString(16);
 106 (-11111111111111111111111).toString(16);
 107 (-0.00001).toString(16);
 108 (-0.000001).toString(16);
 109 (-0.0000001).toString(16);
 110 (-0.00000012).toString(16);
 111 (-0.000000123).toString(16);
 112 (-0.00000001).toString(16);
 113 (-0.000000012).toString(16);
 114 (-0.0000000123).toString(16);
 115
 116 (2,32).toString();
 117 (Math.pow(2,32)-1).toString(16);
 118 (Math.pow(2,32)-1).toString(2);
 119 (10000007).toString(36);
 120 (0).toString(36);
 121 (0).toString(16);
 122 (0).toString(10);
 123 (0).toString(8);
 124 (0).toString(2);
 125 (2,32).toString(2);
 126 (Math.pow(2,32) + 1).toString(2);
 127 (0x100000000000081).toString(16);
 128 (-(-'0x1000000000000081')).toString(16);
 129 (0x100000000000081).toString(2);
 130 (-(Math.pow(2,32)-1)).toString(2);
 131 (-10000007).toString(36);
 132 (-Math.pow(2,32)).toString(2);
 133 (-(Math.pow(2,32) + 1)).toString(2);
 134 (-0x100000000000081).toString(16);
 135 (-0x100000000000081).toString(2);
 136 (1000).toString();
 137 (0.00001).toString();
 138 (1000000000000000128).toString();
 139 (1000000000000000012800).toString();
 140 (-1000000000000000012800).toString();
 141 (0.0000001).toString();
 142 (-0.0000001).toString();
 143 (1000000000000000128000).toString();
 144 (0.000001).toString();
 145 (0.0000001).toString();
 146 (8.5).toString(16);
 147 (-8.5).toString(16);
 148
 149 // ----------------------------------------------------------------------
 150 // toFixed
 151 (NaN).toFixed(2);
 152 (1/0).toFixed(2);
 153 (-1/0).toFixed(2);
 154
 155 (1111111111111111111111).toFixed(8);
 156 (0.1).toFixed(1);
 157 (0.1).toFixed(2);
 158 (0.1).toFixed(3);
 159 (0.01).toFixed(2);
 160 (0.01).toFixed(3);
 161 (0.01).toFixed(4);
 162 (0.001).toFixed(2);
 163 (0.001).toFixed(3);
 164 (0.001).toFixed(4);
 165 (1).toFixed(4);
 166 (1).toFixed(1);
 167 (1).toFixed(0);
 168 (12).toFixed(0);
 169 (1.1).toFixed(0);
 170 (12.1).toFixed(0);
 171 (1.12).toFixed(0);
 172 (12.12).toFixed(0);
 173 (0.0000006).toFixed(7);
 174 (0.00000006).toFixed(8);
 175 (0.00000006).toFixed(9);
 176 (0.00000006).toFixed(10);
 177 (0).toFixed(0);
 178 (0).toFixed(1);
 179 (0).toFixed(2);
 180
 181 (-1111111111111111111111).toFixed(8);
 182 (-0.1).toFixed(1);
 183 (-0.1).toFixed(2);
 184 (-0.1).toFixed(3);
 185 (-0.01).toFixed(2);
 186 (-0.01).toFixed(3);
 187 (-0.01).toFixed(4);
 188 (-0.001).toFixed(2);
 189 (-0.001).toFixed(3);
 190 (-0.001).toFixed(4);
 191 (-1).toFixed(4);
 192 (-1).toFixed(1);
 193 (-1).toFixed(0);
 194 (-1.1).toFixed(0);
 195 (-12.1).toFixed(0);
 196 (-1.12).toFixed(0);
 197 (-12.12).toFixed(0);
 198 (-0.0000006).toFixed(7);
 199 (-0.00000006).toFixed(8);
 200 (-0.00000006).toFixed(9);
 201 (-0.00000006).toFixed(10);
 202 (-0).toFixed(0);
 203 (-0).toFixed(1);
 204 (-0).toFixed(2);
 205
 206 (1000).toFixed();
 207 (0.00001).toFixed();
 208 (0.00001).toFixed(5);
 209 (0.0000000000000000001).toFixed(20);
 210 (0.00001).toFixed(17);
 211 (1).toFixed(17);
 212 (1000000000000000128).toFixed();
 213 (100000000000000128).toFixed(1);
 214 (10000000000000128).toFixed(2);
 215 (10000000000000128).toFixed(20);
 216 (0).toFixed();
 217 ((-42).toFixed(3));
 218 (-1000000000000000128).toFixed();
 219 (-0.0000000000000000001).toFixed(20);
 220 (0.123123123123123).toFixed(20);
 221 // Test that we round up even when the last digit generated is even.
 222 // dtoa does not do this in its original form.
 223 (0.5).toFixed(0);
 224 (-0.5).toFixed(0);
 225 (1.25).toFixed(1);
 226 // This is bizare, but Spidermonkey and KJS behave the same.
 227 (234.20405).toFixed(4);
 228 (234.2040506).toFixed(4);
 229
 230 // ----------------------------------------------------------------------
 231 // toExponential
 232 (1).toExponential();
 233 (11).toExponential();
 234 (112).toExponential();
 235 (1).toExponential(0);
 236 (11).toExponential(0);
 237 (112).toExponential(0);
 238 (1).toExponential(1);
 239 (11).toExponential(1);
 240 (112).toExponential(1);
 241 (1).toExponential(2);
 242 (11).toExponential(2);
 243 (112).toExponential(2);
 244 (1).toExponential(3);
 245 (11).toExponential(3);
 246 (112).toExponential(3);
 247 (0.1).toExponential();
 248 (0.11).toExponential();
 249 (0.112).toExponential();
 250 (0.1).toExponential(0);
 251 (0.11).toExponential(0);
 252 (0.112).toExponential(0);
 253 (0.1).toExponential(1);
 254 (0.11).toExponential(1);
 255 (0.112).toExponential(1);
 256 (0.1).toExponential(2);
 257 (0.11).toExponential(2);
 258 (0.112).toExponential(2);
 259 (0.1).toExponential(3);
 260 (0.11).toExponential(3);
 261 (0.112).toExponential(3);
 262
 263 (-1).toExponential();
 264 (-11).toExponential();
 265 (-112).toExponential();
 266 (-1).toExponential(0);
 267 (-11).toExponential(0);
 268 (-112).toExponential(0);
 269 (-1).toExponential(1);
 270 (-11).toExponential(1);
 271 (-112).toExponential(1);
 272 (-1).toExponential(2);
 273 (-11).toExponential(2);
 274 (-112).toExponential(2);
 275 (-1).toExponential(3);
 276 (-11).toExponential(3);
 277 (-112).toExponential(3);
 278 (-0.1).toExponential();
 279 (-0.11).toExponential();
 280 (-0.112).toExponential();
 281 (-0.1).toExponential(0);
 282 (-0.11).toExponential(0);
 283 (-0.112).toExponential(0);
 284 (-0.1).toExponential(1);
 285 (-0.11).toExponential(1);
 286 (-0.112).toExponential(1);
 287 (-0.1).toExponential(2);
 288 (-0.11).toExponential(2);
 289 (-0.112).toExponential(2);
 290 (-0.1).toExponential(3);
 291 (-0.11).toExponential(3);
 292 (-0.112).toExponential(3);
 293
 294 (NaN).toExponential(2);
 295 (Infinity).toExponential(2);
 296 (-Infinity).toExponential(2);
 297 (1).toExponential(0);
 298 (0).toExponential();
 299 (0).toExponential(2);
 300 (11.2356).toExponential(0);
 301 (11.2356).toExponential(4);
 302 (0.000112356).toExponential(4);
 303 (-0.000112356).toExponential(4);
 304 (0.000112356).toExponential();
 305 (-0.000112356).toExponential();
 306
 307 // ----------------------------------------------------------------------
 308 // toPrecision
 309 (NaN).toPrecision(1);
 310 (Infinity).toPrecision(2);
 311 (-Infinity).toPrecision(2);
 312 (0.000555).toPrecision(15);
 313 (0.000000555).toPrecision(15);
 314 (-0.000000555).toPrecision(15);
 315 (123456789).toPrecision(1);
 316 (123456789).toPrecision(9);
 317 (123456789).toPrecision(8);
 318 (123456789).toPrecision(7);
 319 (-123456789).toPrecision(7);
 320 (-.0000000012345).toPrecision(2);
 321 (-.000000012345).toPrecision(2);
 322 (-.00000012345).toPrecision(2);
 323 (-.0000012345).toPrecision(2);
 324 (-.000012345).toPrecision(2);
 325 (-.00012345).toPrecision(2);
 326 (-.0012345).toPrecision(2);
 327 (-.012345).toPrecision(2);
 328 (-.12345).toPrecision(2);
 329 (-1.2345).toPrecision(2);
 330 (-12.345).toPrecision(2);
 331 (-123.45).toPrecision(2);
 332 (-1234.5).toPrecision(2);
 333 (-12345).toPrecision(2);
 334 (-12345.67).toPrecision(4);
 335 Number(-12344.67).toPrecision(4);
 336 // Test that we round up even when the last digit generated is even.
 337 // dtoa does not do this in its original form.
 338 (1.25).toPrecision(2);
 339 (1.35).toPrecision(2);
 340
 341 // Test the exponential notation output.
 342 (1.2345e+27).toPrecision(1);
 343 (1.2345e+27).toPrecision(2);
 344 (1.2345e+27).toPrecision(3);
 345 (1.2345e+27).toPrecision(4);
 346 (1.2345e+27).toPrecision(5);
 347 (1.2345e+27).toPrecision(6);
 348 (1.2345e+27).toPrecision(7);
 349
 350 (-1.2345e+27).toPrecision(1);
 351 (-1.2345e+27).toPrecision(2);
 352 (-1.2345e+27).toPrecision(3);
 353 (-1.2345e+27).toPrecision(4);
 354 (-1.2345e+27).toPrecision(5);
 355 (-1.2345e+27).toPrecision(6);
 356 (-1.2345e+27).toPrecision(7);
 357
 358
 359 // Test the fixed notation output.
 360 (7).toPrecision(1);
 361 (7).toPrecision(2);
 362 (7).toPrecision(3);
 363
 364 (-7).toPrecision(1);
 365 (-7).toPrecision(2);
 366 (-7).toPrecision(3);
 367
 368 (91).toPrecision(1);
 369 (91).toPrecision(2);
 370 (91).toPrecision(3);
 371 (91).toPrecision(4);
 372
 373 (-91).toPrecision(1);
 374 (-91).toPrecision(2);
 375 (-91).toPrecision(3);
 376 (-91).toPrecision(4);
 377
 378 (91.1234).toPrecision(1);
 379 (91.1234).toPrecision(2);
 380 (91.1234).toPrecision(3);
 381 (91.1234).toPrecision(4);
 382 (91.1234).toPrecision(5);
 383 (91.1234).toPrecision(6);
 384 (91.1234).toPrecision(7);
 385 (91.1234).toPrecision(8);
 386
 387 (-91.1234).toPrecision(1);
 388 (-91.1234).toPrecision(2);
 389 (-91.1234).toPrecision(3);
 390 (-91.1234).toPrecision(4);
 391 (-91.1234).toPrecision(5);
 392 (-91.1234).toPrecision(6);
 393 (-91.1234).toPrecision(7);
 394 (-91.1234).toPrecision(8);