[apple/javascriptcore.git] / tests / mozilla / ecma / GlobalObject / 15.1.2.2-1.js

/* The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is Mozilla Communicator client code, released March
 * 31, 1998.
 *
 * The Initial Developer of the Original Code is Netscape Communications
 * Corporation. Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s): 
 * 
 */
/**
    File Name:          15.1.2.2-1.js
    ECMA Section:       15.1.2.2 Function properties of the global object
                        parseInt( string, radix )

    Description:

    The parseInt function produces an integer value dictated by intepretation
    of the contents of the string argument according to the specified radix.

    When the parseInt function is called, the following steps are taken:

   1.   Call ToString(string).
   2.   Compute a substring of Result(1) consisting of the leftmost character
        that is not a StrWhiteSpaceChar and all characters to the right of
        that character. (In other words, remove leading whitespace.)
   3.   Let sign be 1.
   4.   If Result(2) is not empty and the first character of Result(2) is a
        minus sign -, let sign be -1.
   5.   If Result(2) is not empty and the first character of Result(2) is a
        plus sign + or a minus sign -, then Result(5) is the substring of
        Result(2) produced by removing the first character; otherwise, Result(5)
        is Result(2).
   6.   If the radix argument is not supplied, go to step 12.
   7.   Call ToInt32(radix).
   8.   If Result(7) is zero, go to step 12; otherwise, if Result(7) < 2 or
        Result(7) > 36, return NaN.
   9.   Let R be Result(7).
  10.   If R = 16 and the length of Result(5) is at least 2 and the first two
        characters of Result(5) are either "0x" or "0X", let S be the substring
        of Result(5) consisting of all but the first two characters; otherwise,
        let S be Result(5).
  11.   Go to step 22.
  12.   If Result(5) is empty or the first character of Result(5) is not 0,
        go to step 20.
  13.   If the length of Result(5) is at least 2 and the second character of
        Result(5) is x or X, go to step 17.
  14.   Let R be 8.
  15.   Let S be Result(5).
  16.   Go to step 22.
  17.   Let R be 16.
  18.   Let S be the substring of Result(5) consisting of all but the first
        two characters.
  19.   Go to step 22.
  20.   Let R be 10.
  21.   Let S be Result(5).
  22.   If S contains any character that is not a radix-R digit, then let Z be
        the substring of S consisting of all characters to the left of the
        leftmost such character; otherwise, let Z be S.
  23.   If Z is empty, return NaN.
  24.   Compute the mathematical integer value that is represented by Z in
        radix-R notation. (But if R is 10 and Z contains more than 20
        significant digits, every 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 Result(24) may be an implementation-dependent
        approximation to the mathematical integer value that is represented
        by Z in radix-R notation.)
  25.   Compute the number value for Result(24).
  26.   Return sign Result(25).

    Note that parseInt may interpret only a leading portion of the string as
    an integer value; it ignores any characters that cannot be interpreted as
    part of the notation of an integer, and no indication is given that any
    such characters were ignored.

    Author:             christine@netscape.com
    Date:               28 october 1997

*/
    var SECTION = "15.1.2.2-1";
    var VERSION = "ECMA_1";
    startTest();
    var TITLE   = "parseInt(string, radix)";
    var BUGNUMBER="111199";

    writeHeaderToLog( SECTION + " "+ TITLE);

    var testcases = getTestCases();

    test();

function getTestCases() {
    var array = new Array();
    var item = 0;

    var HEX_STRING = "0x0";
    var HEX_VALUE = 0;

    array[item++] = new TestCase( SECTION,  "parseInt.length",      2,      parseInt.length );
    array[item++] = new TestCase( SECTION,  "parseInt.length = 0; parseInt.length",     2,      eval("parseInt.length = 0; parseInt.length") );
    array[item++] = new TestCase( SECTION,  "var PROPS=''; for ( var p in parseInt ) { PROPS += p; }; PROPS",   "", eval("var PROPS=''; for ( var p in parseInt ) { PROPS += p; }; PROPS") );
    array[item++] = new TestCase( SECTION,  "delete parseInt.length",   false,  delete parseInt.length );
    array[item++] = new TestCase( SECTION,  "delete parseInt.length; parseInt.length",  2,  eval("delete parseInt.length; parseInt.length") );
    array[item++] = new TestCase( SECTION,  "parseInt.length = null; parseInt.length",  2,  eval("parseInt.length = null; parseInt.length") );

    array[item++] = new TestCase( SECTION,  "parseInt()",       NaN,    parseInt() );
    array[item++] = new TestCase( SECTION,  "parseInt('')",     NaN,    parseInt("") );
    array[item++] = new TestCase( SECTION,  "parseInt('','')",  NaN,    parseInt("","") );
    array[item++] = new TestCase( SECTION,
                    "parseInt(\"     0xabcdef     ",
                    11259375,
                    parseInt( "      0xabcdef     " ));

    array[item++] = new TestCase( SECTION,
                    "parseInt(\"     0XABCDEF     ",
                    11259375,
                    parseInt( "      0XABCDEF     " ) );

    array[item++] = new TestCase( SECTION,
                    "parseInt( 0xabcdef )",
                    11259375,
                    parseInt( "0xabcdef") );

    array[item++] = new TestCase( SECTION,
                    "parseInt( 0XABCDEF )",
                    11259375,
                    parseInt( "0XABCDEF") );

    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")",    HEX_VALUE,  parseInt(HEX_STRING) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "0X0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")",    HEX_VALUE,  parseInt(HEX_STRING) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)",    HEX_VALUE,  parseInt(HEX_STRING,16) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)",    HEX_VALUE,  parseInt(HEX_STRING,16) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",null)",    HEX_VALUE,  parseInt(HEX_STRING,null) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+", void 0)",    HEX_VALUE,  parseInt(HEX_STRING, void 0) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }

    // a few tests with spaces

    for ( var space = " ", HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0;
        POWER < 15;
        POWER++, HEX_STRING = HEX_STRING +"f", space += " ")
    {
        array[item++] = new TestCase( SECTION, "parseInt("+space+HEX_STRING+space+", void 0)",    HEX_VALUE,  parseInt(space+HEX_STRING+space, void 0) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }

    // a few tests with negative numbers
    for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")",    HEX_VALUE,  parseInt(HEX_STRING) );
        HEX_VALUE -= Math.pow(16,POWER)*15;
    }

    // we should stop parsing when we get to a value that is not a numeric literal for the type we expect

    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+"g,16)",    HEX_VALUE,  parseInt(HEX_STRING+"g",16) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+"g,16)",    HEX_VALUE,  parseInt(HEX_STRING+"G",16) );
        HEX_VALUE += Math.pow(16,POWER)*15;
    }

    for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")",    HEX_VALUE,  parseInt(HEX_STRING) );
        HEX_VALUE -= Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "-0X0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")",    HEX_VALUE,  parseInt(HEX_STRING) );
        HEX_VALUE -= Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)",    HEX_VALUE,  parseInt(HEX_STRING,16) );
        HEX_VALUE -= Math.pow(16,POWER)*15;
    }
    for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)",    HEX_VALUE,  parseInt(HEX_STRING,16) );
        HEX_VALUE -= Math.pow(16,POWER)*15;
    }

    //  let us do some octal tests.  numbers that start with 0 and do not provid a radix should
    //  default to using "0" as a radix.

    var OCT_STRING = "0";
    var OCT_VALUE = 0;

    for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+")",    OCT_VALUE,  parseInt(OCT_STRING) );
        OCT_VALUE += Math.pow(8,POWER)*7;
    }

    for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+")",    OCT_VALUE,  parseInt(OCT_STRING) );
        OCT_VALUE -= Math.pow(8,POWER)*7;
    }

    // should get the same results as above if we provid the radix of 8 (or 010)

    for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+",8)",    OCT_VALUE,  parseInt(OCT_STRING,8) );
        OCT_VALUE += Math.pow(8,POWER)*7;
    }
    for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+",010)",    OCT_VALUE,  parseInt(OCT_STRING,010) );
        OCT_VALUE -= Math.pow(8,POWER)*7;
    }

    // we shall stop parsing digits when we get one that isn't a numeric literal of the type we think
    // it should be.
    for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+"8,8)",    OCT_VALUE,  parseInt(OCT_STRING+"8",8) );
        OCT_VALUE += Math.pow(8,POWER)*7;
    }
    for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
        array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+"8,010)",    OCT_VALUE,  parseInt(OCT_STRING+"8",010) );
        OCT_VALUE -= Math.pow(8,POWER)*7;
    }

    array[item++] = new TestCase( SECTION, "parseInt( '0x' )",              NaN,        parseInt("0x") );
    array[item++] = new TestCase( SECTION, "parseInt( '0X' )",              NaN,        parseInt("0X") );

    array[item++] = new TestCase( SECTION, "parseInt( '11111111112222222222' )",    11111111112222222222,   parseInt("11111111112222222222") );
    array[item++] = new TestCase( SECTION, "parseInt( '111111111122222222223' )",    111111111122222222220,   parseInt("111111111122222222223") );
    array[item++] = new TestCase( SECTION, "parseInt( '11111111112222222222',10 )",    11111111112222222222,   parseInt("11111111112222222222",10) );
    array[item++] = new TestCase( SECTION, "parseInt( '111111111122222222223',10 )",    111111111122222222220,   parseInt("111111111122222222223",10) );

    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', -1 )",  Number.NaN,    parseInt("01234567890",-1) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 0 )",  Number.NaN,     parseInt("01234567890",1) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 1 )",  Number.NaN,     parseInt("01234567890",1) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 2 )",  1,              parseInt("01234567890",2) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 3 )",  5,              parseInt("01234567890",3) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 4 )",  27,             parseInt("01234567890",4) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 5 )",  194,            parseInt("01234567890",5) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 6 )",  1865,           parseInt("01234567890",6) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 7 )",  22875,          parseInt("01234567890",7) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 8 )",  342391,         parseInt("01234567890",8) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 9 )",  6053444,        parseInt("01234567890",9) );
    array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 10 )", 1234567890,     parseInt("01234567890",10) );

    // need more test cases with hex radix

    array[item++] = new TestCase( SECTION, "parseInt( '1234567890', '0xa')", 1234567890, parseInt("1234567890","0xa") );

    array[item++] = new TestCase( SECTION, "parseInt( '012345', 11 )",      17715,          parseInt("012345",11) );

    array[item++] = new TestCase( SECTION, "parseInt( '012345', 35 )",      1590195,        parseInt("012345",35) );
    array[item++] = new TestCase( SECTION, "parseInt( '012345', 36 )",      1776965,        parseInt("012345",36) );
    array[item++] = new TestCase( SECTION, "parseInt( '012345', 37 )",      Number.NaN,     parseInt("012345",37) );

    return ( array );
}
function test( array ) {
    for ( tc=0 ; tc < testcases.length; tc++ ) {
        testcases[tc].passed = writeTestCaseResult(
                            testcases[tc].expect,
                            testcases[tc].actual,
                            testcases[tc].description +" = "+ testcases[tc].actual );

        testcases[tc].reason += ( testcases[tc].passed ) ? "" : "wrong value ";
    }
    stopTest();
    return ( testcases );
}
Commit	Line	Data
b37bf2e1 A	1	/* The contents of this file are subject to the Netscape Public
	2	* License Version 1.1 (the "License"); you may not use this file
	3	* except in compliance with the License. You may obtain a copy of
	4	* the License at http://www.mozilla.org/NPL/
	5	*
	6	* Software distributed under the License is distributed on an "AS
	7	* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
	8	* implied. See the License for the specific language governing
	9	* rights and limitations under the License.
	10	*
	11	* The Original Code is Mozilla Communicator client code, released March
	12	* 31, 1998.
	13	*
	14	* The Initial Developer of the Original Code is Netscape Communications
	15	* Corporation. Portions created by Netscape are
	16	* Copyright (C) 1998 Netscape Communications Corporation. All
	17	* Rights Reserved.
	18	*
	19	* Contributor(s):
	20	*
	21	*/
	22	/**
	23	File Name: 15.1.2.2-1.js
	24	ECMA Section: 15.1.2.2 Function properties of the global object
	25	parseInt( string, radix )
	26
	27	Description:
	28
	29	The parseInt function produces an integer value dictated by intepretation
	30	of the contents of the string argument according to the specified radix.
	31
	32	When the parseInt function is called, the following steps are taken:
	33
	34	1. Call ToString(string).
	35	2. Compute a substring of Result(1) consisting of the leftmost character
	36	that is not a StrWhiteSpaceChar and all characters to the right of
	37	that character. (In other words, remove leading whitespace.)
	38	3. Let sign be 1.
	39	4. If Result(2) is not empty and the first character of Result(2) is a
	40	minus sign -, let sign be -1.
	41	5. If Result(2) is not empty and the first character of Result(2) is a
	42	plus sign + or a minus sign -, then Result(5) is the substring of
	43	Result(2) produced by removing the first character; otherwise, Result(5)
	44	is Result(2).
	45	6. If the radix argument is not supplied, go to step 12.
	46	7. Call ToInt32(radix).
	47	8. If Result(7) is zero, go to step 12; otherwise, if Result(7) < 2 or
	48	Result(7) > 36, return NaN.
	49	9. Let R be Result(7).
	50	10. If R = 16 and the length of Result(5) is at least 2 and the first two
	51	characters of Result(5) are either "0x" or "0X", let S be the substring
	52	of Result(5) consisting of all but the first two characters; otherwise,
	53	let S be Result(5).
	54	11. Go to step 22.
	55	12. If Result(5) is empty or the first character of Result(5) is not 0,
	56	go to step 20.
	57	13. If the length of Result(5) is at least 2 and the second character of
	58	Result(5) is x or X, go to step 17.
	59	14. Let R be 8.
	60	15. Let S be Result(5).
	61	16. Go to step 22.
	62	17. Let R be 16.
	63	18. Let S be the substring of Result(5) consisting of all but the first
	64	two characters.
65	19. Go to step 22.
66	20. Let R be 10.
67	21. Let S be Result(5).
68	22. If S contains any character that is not a radix-R digit, then let Z be
69	the substring of S consisting of all characters to the left of the
70	leftmost such character; otherwise, let Z be S.
71	23. If Z is empty, return NaN.
72	24. Compute the mathematical integer value that is represented by Z in
73	radix-R notation. (But if R is 10 and Z contains more than 20
74	significant digits, every digit after the 20th may be replaced by a 0
75	digit, at the option of the implementation; and if R is not 2, 4, 8,
76	10, 16, or 32, then Result(24) may be an implementation-dependent
77	approximation to the mathematical integer value that is represented
78	by Z in radix-R notation.)
79	25. Compute the number value for Result(24).
80	26. Return sign Result(25).
81
82	Note that parseInt may interpret only a leading portion of the string as
83	an integer value; it ignores any characters that cannot be interpreted as
84	part of the notation of an integer, and no indication is given that any
85	such characters were ignored.
86
87	Author: christine@netscape.com
88	Date: 28 october 1997
89
90	*/
91	var SECTION = "15.1.2.2-1";
92	var VERSION = "ECMA_1";
93	startTest();
94	var TITLE = "parseInt(string, radix)";
95	var BUGNUMBER="111199";
96
97	writeHeaderToLog( SECTION + " "+ TITLE);
98
99	var testcases = getTestCases();
100
101	test();
102
103	function getTestCases() {
104	var array = new Array();
105	var item = 0;
106
107	var HEX_STRING = "0x0";
108	var HEX_VALUE = 0;
109
110	array[item++] = new TestCase( SECTION, "parseInt.length", 2, parseInt.length );
111	array[item++] = new TestCase( SECTION, "parseInt.length = 0; parseInt.length", 2, eval("parseInt.length = 0; parseInt.length") );
112	array[item++] = new TestCase( SECTION, "var PROPS=''; for ( var p in parseInt ) { PROPS += p; }; PROPS", "", eval("var PROPS=''; for ( var p in parseInt ) { PROPS += p; }; PROPS") );
113	array[item++] = new TestCase( SECTION, "delete parseInt.length", false, delete parseInt.length );
114	array[item++] = new TestCase( SECTION, "delete parseInt.length; parseInt.length", 2, eval("delete parseInt.length; parseInt.length") );
115	array[item++] = new TestCase( SECTION, "parseInt.length = null; parseInt.length", 2, eval("parseInt.length = null; parseInt.length") );
116
117	array[item++] = new TestCase( SECTION, "parseInt()", NaN, parseInt() );
118	array[item++] = new TestCase( SECTION, "parseInt('')", NaN, parseInt("") );
119	array[item++] = new TestCase( SECTION, "parseInt('','')", NaN, parseInt("","") );
120	array[item++] = new TestCase( SECTION,
121	"parseInt(\" 0xabcdef ",
122	11259375,
123	parseInt( " 0xabcdef " ));
124
125	array[item++] = new TestCase( SECTION,
126	"parseInt(\" 0XABCDEF ",
127	11259375,
128	parseInt( " 0XABCDEF " ) );
129
130	array[item++] = new TestCase( SECTION,
131	"parseInt( 0xabcdef )",
132	11259375,
133	parseInt( "0xabcdef") );
134
135	array[item++] = new TestCase( SECTION,
136	"parseInt( 0XABCDEF )",
137	11259375,
138	parseInt( "0XABCDEF") );
139
140	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
141	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")", HEX_VALUE, parseInt(HEX_STRING) );
142	HEX_VALUE += Math.pow(16,POWER)*15;
143	}
144	for ( HEX_STRING = "0X0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
145	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")", HEX_VALUE, parseInt(HEX_STRING) );
146	HEX_VALUE += Math.pow(16,POWER)*15;
147	}
148	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
149	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)", HEX_VALUE, parseInt(HEX_STRING,16) );
150	HEX_VALUE += Math.pow(16,POWER)*15;
151	}
152	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
153	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)", HEX_VALUE, parseInt(HEX_STRING,16) );
154	HEX_VALUE += Math.pow(16,POWER)*15;
155	}
156	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
157	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",null)", HEX_VALUE, parseInt(HEX_STRING,null) );
158	HEX_VALUE += Math.pow(16,POWER)*15;
159	}
160	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
161	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+", void 0)", HEX_VALUE, parseInt(HEX_STRING, void 0) );
162	HEX_VALUE += Math.pow(16,POWER)*15;
163	}
164
165	// a few tests with spaces
166
167	for ( var space = " ", HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0;
168	POWER < 15;
169	POWER++, HEX_STRING = HEX_STRING +"f", space += " ")
170	{
171	array[item++] = new TestCase( SECTION, "parseInt("+space+HEX_STRING+space+", void 0)", HEX_VALUE, parseInt(space+HEX_STRING+space, void 0) );
172	HEX_VALUE += Math.pow(16,POWER)*15;
173	}
174
175	// a few tests with negative numbers
176	for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
177	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")", HEX_VALUE, parseInt(HEX_STRING) );
178	HEX_VALUE -= Math.pow(16,POWER)*15;
179	}
180
181	// we should stop parsing when we get to a value that is not a numeric literal for the type we expect
182
183	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
184	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+"g,16)", HEX_VALUE, parseInt(HEX_STRING+"g",16) );
185	HEX_VALUE += Math.pow(16,POWER)*15;
186	}
187	for ( HEX_STRING = "0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
188	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+"g,16)", HEX_VALUE, parseInt(HEX_STRING+"G",16) );
189	HEX_VALUE += Math.pow(16,POWER)*15;
190	}
191
192	for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
193	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")", HEX_VALUE, parseInt(HEX_STRING) );
194	HEX_VALUE -= Math.pow(16,POWER)*15;
195	}
196	for ( HEX_STRING = "-0X0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
197	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+")", HEX_VALUE, parseInt(HEX_STRING) );
198	HEX_VALUE -= Math.pow(16,POWER)*15;
199	}
200	for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
201	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)", HEX_VALUE, parseInt(HEX_STRING,16) );
202	HEX_VALUE -= Math.pow(16,POWER)*15;
203	}
204	for ( HEX_STRING = "-0x0", HEX_VALUE = 0, POWER = 0; POWER < 15; POWER++, HEX_STRING = HEX_STRING +"f" ) {
205	array[item++] = new TestCase( SECTION, "parseInt("+HEX_STRING+",16)", HEX_VALUE, parseInt(HEX_STRING,16) );
206	HEX_VALUE -= Math.pow(16,POWER)*15;
207	}
208
209	// let us do some octal tests. numbers that start with 0 and do not provid a radix should
210	// default to using "0" as a radix.
211
212	var OCT_STRING = "0";
213	var OCT_VALUE = 0;
214
215	for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
216	array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+")", OCT_VALUE, parseInt(OCT_STRING) );
217	OCT_VALUE += Math.pow(8,POWER)*7;
218	}
219
220	for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
221	array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+")", OCT_VALUE, parseInt(OCT_STRING) );
222	OCT_VALUE -= Math.pow(8,POWER)*7;
223	}
224
225	// should get the same results as above if we provid the radix of 8 (or 010)
226
227	for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
228	array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+",8)", OCT_VALUE, parseInt(OCT_STRING,8) );
229	OCT_VALUE += Math.pow(8,POWER)*7;
230	}
231	for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
232	array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+",010)", OCT_VALUE, parseInt(OCT_STRING,010) );
233	OCT_VALUE -= Math.pow(8,POWER)*7;
234	}
235
236	// we shall stop parsing digits when we get one that isn't a numeric literal of the type we think
237	// it should be.
238	for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
239	array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+"8,8)", OCT_VALUE, parseInt(OCT_STRING+"8",8) );
240	OCT_VALUE += Math.pow(8,POWER)*7;
241	}
242	for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
243	array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+"8,010)", OCT_VALUE, parseInt(OCT_STRING+"8",010) );
244	OCT_VALUE -= Math.pow(8,POWER)*7;
245	}
246
247	array[item++] = new TestCase( SECTION, "parseInt( '0x' )", NaN, parseInt("0x") );
248	array[item++] = new TestCase( SECTION, "parseInt( '0X' )", NaN, parseInt("0X") );
249
250	array[item++] = new TestCase( SECTION, "parseInt( '11111111112222222222' )", 11111111112222222222, parseInt("11111111112222222222") );
251	array[item++] = new TestCase( SECTION, "parseInt( '111111111122222222223' )", 111111111122222222220, parseInt("111111111122222222223") );
252	array[item++] = new TestCase( SECTION, "parseInt( '11111111112222222222',10 )", 11111111112222222222, parseInt("11111111112222222222",10) );
253	array[item++] = new TestCase( SECTION, "parseInt( '111111111122222222223',10 )", 111111111122222222220, parseInt("111111111122222222223",10) );
254
255	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', -1 )", Number.NaN, parseInt("01234567890",-1) );
256	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 0 )", Number.NaN, parseInt("01234567890",1) );
257	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 1 )", Number.NaN, parseInt("01234567890",1) );
258	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 2 )", 1, parseInt("01234567890",2) );
259	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 3 )", 5, parseInt("01234567890",3) );
260	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 4 )", 27, parseInt("01234567890",4) );
261	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 5 )", 194, parseInt("01234567890",5) );
262	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 6 )", 1865, parseInt("01234567890",6) );
263	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 7 )", 22875, parseInt("01234567890",7) );
264	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 8 )", 342391, parseInt("01234567890",8) );
265	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 9 )", 6053444, parseInt("01234567890",9) );
266	array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 10 )", 1234567890, parseInt("01234567890",10) );
267
268	// need more test cases with hex radix
269
270	array[item++] = new TestCase( SECTION, "parseInt( '1234567890', '0xa')", 1234567890, parseInt("1234567890","0xa") );
271
272	array[item++] = new TestCase( SECTION, "parseInt( '012345', 11 )", 17715, parseInt("012345",11) );
273
274	array[item++] = new TestCase( SECTION, "parseInt( '012345', 35 )", 1590195, parseInt("012345",35) );
275	array[item++] = new TestCase( SECTION, "parseInt( '012345', 36 )", 1776965, parseInt("012345",36) );
276	array[item++] = new TestCase( SECTION, "parseInt( '012345', 37 )", Number.NaN, parseInt("012345",37) );
277
278	return ( array );
279	}
280	function test( array ) {
281	for ( tc=0 ; tc < testcases.length; tc++ ) {
282	testcases[tc].passed = writeTestCaseResult(
283	testcases[tc].expect,
284	testcases[tc].actual,
285	testcases[tc].description +" = "+ testcases[tc].actual );
286
287	testcases[tc].reason += ( testcases[tc].passed ) ? "" : "wrong value ";
288	}
289	stopTest();
290	return ( testcases );
291	}