tests/mozilla/ecma/GlobalObject/15.1.2.2-1.js

   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 - ES5 does not permit octal, these must be treated as decimal.
 210
 211     var OCT_STRING = "0";
 212     var OCT_VALUE = 0;
 213
 214     for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
 215         array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+")",    OCT_VALUE,  parseInt(OCT_STRING) );
 216         OCT_VALUE += Math.pow(10,POWER)*7;
 217     }
 218
 219     for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
 220         array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+")",    OCT_VALUE,  parseInt(OCT_STRING) );
 221         OCT_VALUE -= Math.pow(10,POWER)*7;
 222     }
 223
 224     // should get the same results as above if we provid the radix of 8 (or 010)
 225
 226     for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
 227         array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+",8)",    OCT_VALUE,  parseInt(OCT_STRING,8) );
 228         OCT_VALUE += Math.pow(8,POWER)*7;
 229     }
 230     for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
 231         array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+",010)",    OCT_VALUE,  parseInt(OCT_STRING,010) );
 232         OCT_VALUE -= Math.pow(8,POWER)*7;
 233     }
 234
 235     // we shall stop parsing digits when we get one that isn't a numeric literal of the type we think
 236     // it should be.
 237     for ( OCT_STRING = "0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
 238         array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+"8,8)",    OCT_VALUE,  parseInt(OCT_STRING+"8",8) );
 239         OCT_VALUE += Math.pow(8,POWER)*7;
 240     }
 241     for ( OCT_STRING = "-0", OCT_VALUE = 0, POWER = 0; POWER < 15; POWER++, OCT_STRING = OCT_STRING +"7" ) {
 242         array[item++] = new TestCase( SECTION, "parseInt("+OCT_STRING+"8,010)",    OCT_VALUE,  parseInt(OCT_STRING+"8",010) );
 243         OCT_VALUE -= Math.pow(8,POWER)*7;
 244     }
 245
 246     array[item++] = new TestCase( SECTION, "parseInt( '0x' )",              NaN,        parseInt("0x") );
 247     array[item++] = new TestCase( SECTION, "parseInt( '0X' )",              NaN,        parseInt("0X") );
 248
 249     array[item++] = new TestCase( SECTION, "parseInt( '11111111112222222222' )",    11111111112222222222,   parseInt("11111111112222222222") );
 250     array[item++] = new TestCase( SECTION, "parseInt( '111111111122222222223' )",    111111111122222222220,   parseInt("111111111122222222223") );
 251     array[item++] = new TestCase( SECTION, "parseInt( '11111111112222222222',10 )",    11111111112222222222,   parseInt("11111111112222222222",10) );
 252     array[item++] = new TestCase( SECTION, "parseInt( '111111111122222222223',10 )",    111111111122222222220,   parseInt("111111111122222222223",10) );
 253
 254     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', -1 )",  Number.NaN,    parseInt("01234567890",-1) );
 255     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 0 )",  Number.NaN,     parseInt("01234567890",1) );
 256     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 1 )",  Number.NaN,     parseInt("01234567890",1) );
 257     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 2 )",  1,              parseInt("01234567890",2) );
 258     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 3 )",  5,              parseInt("01234567890",3) );
 259     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 4 )",  27,             parseInt("01234567890",4) );
 260     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 5 )",  194,            parseInt("01234567890",5) );
 261     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 6 )",  1865,           parseInt("01234567890",6) );
 262     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 7 )",  22875,          parseInt("01234567890",7) );
 263     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 8 )",  342391,         parseInt("01234567890",8) );
 264     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 9 )",  6053444,        parseInt("01234567890",9) );
 265     array[item++] = new TestCase( SECTION, "parseInt( '01234567890', 10 )", 1234567890,     parseInt("01234567890",10) );
 266
 267     // need more test cases with hex radix
 268
 269     array[item++] = new TestCase( SECTION, "parseInt( '1234567890', '0xa')", 1234567890, parseInt("1234567890","0xa") );
 270
 271     array[item++] = new TestCase( SECTION, "parseInt( '012345', 11 )",      17715,          parseInt("012345",11) );
 272
 273     array[item++] = new TestCase( SECTION, "parseInt( '012345', 35 )",      1590195,        parseInt("012345",35) );
 274     array[item++] = new TestCase( SECTION, "parseInt( '012345', 36 )",      1776965,        parseInt("012345",36) );
 275     array[item++] = new TestCase( SECTION, "parseInt( '012345', 37 )",      Number.NaN,     parseInt("012345",37) );
 276
 277     return ( array );
 278 }
 279 function test( array ) {
 280     for ( tc=0 ; tc < testcases.length; tc++ ) {
 281         testcases[tc].passed = writeTestCaseResult(
 282                             testcases[tc].expect,
 283                             testcases[tc].actual,
 284                             testcases[tc].description +" = "+ testcases[tc].actual );
 285
 286         testcases[tc].reason += ( testcases[tc].passed ) ? "" : "wrong value ";
 287     }
 288     stopTest();
 289     return ( testcases );
 290 }