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); 335Number(-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); 395 396