| // Any copyright is dedicated to the Public Domain. |
| // http://creativecommons.org/licenses/publicdomain/ |
| |
| //----------------------------------------------------------------------------- |
| var BUGNUMBER = 577536; |
| var summary = "ES5 15.1.2.2 parseInt(string, radix)"; |
| |
| print(BUGNUMBER + ": " + summary); |
| |
| /************** |
| * BEGIN TEST * |
| **************/ |
| |
| var str, radix; |
| var upvar; |
| |
| /* 1. Let inputString be ToString(string). */ |
| |
| assertEq(parseInt({ toString: function() { return "17" } }, 10), 17); |
| |
| upvar = 0; |
| str = { get toString() { upvar++; return function() { upvar++; return "12345"; } } }; |
| assertEq(parseInt(str, 10), 12345); |
| assertEq(upvar, 2); |
| |
| |
| /* |
| * 2. Let S be a newly created substring of inputString consisting of the first |
| * character that is not a StrWhiteSpaceChar and all characters following |
| * that character. (In other words, remove leading white space.) |
| */ |
| |
| var ws = |
| ["\t", "\v", "\f", " ", "\xA0", "\uFEFF", |
| "\u2004", "\u3000", // a few Unicode whitespaces |
| "\r", "\n", "\u2028", "\u2029"]; |
| |
| str = "8675309"; |
| for (var i = 0, sz = ws.length; i < sz; i++) |
| { |
| assertEq(parseInt(ws[i] + str, 10), 8675309); |
| for (var j = 0, sz = ws.length; j < sz; j++) |
| { |
| assertEq(parseInt(ws[i] + ws[j] + str, 10), 8675309, |
| ws[i].charCodeAt(0).toString(16) + ", " + |
| ws[j].charCodeAt(0).toString(16)); |
| } |
| } |
| |
| |
| /* |
| * 3. Let sign be 1. |
| * 4. If S is not empty and the first character of S is a minus sign -, let |
| * sign be −1. |
| */ |
| str = "5552368"; |
| assertEq(parseInt("-" + str, 10), -parseInt(str, 10)); |
| assertEq(parseInt(" -" + str, 10), -parseInt(str, 10)); |
| assertEq(parseInt("-", 10), NaN); |
| assertEq(parseInt("", 10), NaN); |
| assertEq(parseInt("-0", 10), -0); |
| |
| |
| /* |
| * 5. If S is not empty and the first character of S is a plus sign + or a |
| * minus sign -, then remove the first character from S. |
| */ |
| assertEq(parseInt("+12345", 10), 12345); |
| assertEq(parseInt(" +12345", 10), 12345); |
| assertEq(parseInt("-12345", 10), -12345); |
| assertEq(parseInt(" -12345", 10), -12345); |
| |
| |
| /* |
| * 6. Let R = ToInt32(radix). |
| */ |
| |
| upvar = ""; |
| str = |
| { toString: function() { if (!upvar) upvar = "string"; return "42"; } }; |
| radix = |
| { toString: function() { if (!upvar) upvar = "radix"; return "10"; } }; |
| |
| assertEq(parseInt(str, radix), 42); |
| assertEq(upvar, "string"); |
| |
| assertEq(parseInt("123", null), 123); |
| assertEq(parseInt("123", undefined), 123); |
| assertEq(parseInt("123", NaN), 123); |
| assertEq(parseInt("123", -0), 123); |
| assertEq(parseInt("10", 72057594037927950), 16); |
| assertEq(parseInt("10", -4294967292), 4); |
| assertEq(parseInt("0x10", 1e308), 16); |
| assertEq(parseInt("10", 1e308), 10); |
| assertEq(parseInt("10", { valueOf: function() { return 16; } }), 16); |
| |
| |
| /* |
| * 7. Let stripPrefix be true. |
| * 8. If R ≠ 0, then |
| * a. If R < 2 or R > 36, then return NaN. |
| * b. If R ≠ 16, let stripPrefix be false. |
| * 9. Else, R = 0 |
| * a. Let R = 10. |
| * 10. If stripPrefix is true, then |
| * a. If the length of S is at least 2 and the first two characters of S |
| * are either “0x” or “0X”, then remove the first two characters from S and |
| * let R = 16. |
| */ |
| var vs = ["1", "51", "917", "2343", "99963"]; |
| for (var i = 0, sz = vs.length; i < sz; i++) |
| assertEq(parseInt(vs[i], 0), parseInt(vs[i], 10), "bad " + vs[i]); |
| |
| assertEq(parseInt("0x10"), 16); |
| assertEq(parseInt("0x10", 0), 16); |
| assertEq(parseInt("0x10", 16), 16); |
| assertEq(parseInt("0x10", 8), 0); |
| assertEq(parseInt("-0x10", 16), -16); |
| |
| assertEq(parseInt("5", 1), NaN); |
| assertEq(parseInt("5", 37), NaN); |
| assertEq(parseInt("5", { valueOf: function() { return -1; } }), NaN); |
| |
| |
| /* |
| * 11. If S contains any character that is not a radix-R digit, then let Z be |
| * the substring of S consisting of all characters before the first such |
| * character; otherwise, let Z be S. |
| * 12. If Z is empty, return NaN. |
| */ |
| assertEq(parseInt(""), NaN); |
| assertEq(parseInt("ohai"), NaN); |
| assertEq(parseInt("0xohai"), NaN); |
| assertEq(parseInt("-ohai"), NaN); |
| assertEq(parseInt("+ohai"), NaN); |
| assertEq(parseInt(" ohai"), NaN); |
| |
| assertEq(parseInt("0xaohai"), 10); |
| assertEq(parseInt("hohai", 18), 17); |
| |
| |
| /* |
| * 13. Let mathInt be the mathematical integer value that is represented by Z |
| * in radix-R notation, using the letters A-Z and a-z for digits with |
| * values 10 through 35. (However, if R is 10 and Z contains more than 20 |
| * significant digits, every significant digit after the 20th may be |
| * replaced by a 0 digit, at the option of the implementation; and if R is |
| * not 2, 4, 8, 10, 16, or 32, then mathInt may be an implementation- |
| * dependent approximation to the mathematical integer value that is |
| * represented by Z in radix-R notation.) |
| * 14. Let number be the Number value for mathInt. |
| * 15. Return sign × number. |
| */ |
| assertEq(parseInt("ohai", 36), 1142154); |
| assertEq(parseInt("0ohai", 36), 1142154); |
| assertEq(parseInt("00ohai", 36), 1142154); |
| assertEq(parseInt("A", 16), 10); |
| assertEq(parseInt("0A", 16), 10); |
| assertEq(parseInt("00A", 16), 10); |
| assertEq(parseInt("A", 17), 10); |
| assertEq(parseInt("0A", 17), 10); |
| assertEq(parseInt("00A", 17), 10); |
| |
| |
| /******************************************************************************/ |
| |
| if (typeof reportCompare === "function") |
| reportCompare(true, true); |
| |
| print("All tests passed!"); |