JavaScriptCore-461.tar.gz

[apple/javascriptcore.git] / tests / mozilla / ecma / shell.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): 
 *
 */
/*
 * JavaScript shared functions file for running the tests in either
 * stand-alone JavaScript engine.  To run a test, first load this file,
 * then load the test script.
 */

var     completed =     false;
var     testcases;
var tc = 0;

SECTION = "";
VERSION = "";
BUGNUMBER =     "";

/*
 * constant strings
 */
var     GLOBAL = "[object global]";
var PASSED = " PASSED!"
var FAILED = " FAILED! expected: ";

var     DEBUG = false;



/* wrapper for test cas constructor that doesn't require the SECTION
 * argument.
 */

function AddTestCase( description, expect, actual ) {
    testcases[tc++] = new TestCase( SECTION, description, expect, actual );
}

/*
 * TestCase constructor
 *
 */

function TestCase( n, d, e,     a )     {
        this.name                = n;
        this.description = d;
        this.expect              = e;
        this.actual              = a;
        this.passed              = true;
        this.reason              = "";
        this.bugnumber    =     BUGNUMBER;

        this.passed     = getTestCaseResult( this.expect, this.actual );
        if ( DEBUG ) {
                writeLineToLog( "added " + this.description     );
        }
}

/*
 * Set up test environment.
 *
 */
function startTest() {
    if ( version ) {
        //      JavaScript 1.3 is supposed to be compliant ecma version 1.0
            if ( VERSION ==     "ECMA_1" ) {
                    version     ( "130" );
        }
            if ( VERSION ==     "JS_1.3" ) {
                    version     ( "130" );
        }
            if ( VERSION ==     "JS_1.2" ) {
                    version     ( "120" );
        }
            if ( VERSION  == "JS_1.1" ) {
                    version     ( "110" );
        }
            // for ecma version 2.0, we will leave the javascript version to
        // the default ( for now ).
    }

    // print out bugnumber

    if ( BUGNUMBER ) {
            writeLineToLog ("BUGNUMBER: " + BUGNUMBER );
    }

    testcases = new Array();
    tc = 0;
}


function test() {
    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 );
}

/*
 * Compare expected result to the actual result and figure out whether
 * the test case passed.
 */
function getTestCaseResult(     expect, actual ) {
        //      because ( NaN == NaN ) always returns false, need to do
        //      a special compare to see if     we got the right result.
                if ( actual     != actual )     {
                        if ( typeof     actual == "object" ) {
                                actual = "NaN object";
                        } else {
                                actual = "NaN number";
                        }
                }
                if ( expect     != expect )     {
                        if ( typeof     expect == "object" ) {
                                expect = "NaN object";
                        } else {
                                expect = "NaN number";
                        }
                }

                var     passed = ( expect == actual     ) ?     true : false;

        //      if both objects are     numbers
        // need to replace w/ IEEE standard     for     rounding
                if (    !passed
                                && typeof(actual) == "number"
                                && typeof(expect) == "number"
                        ) {
                                if ( Math.abs(actual-expect) < 0.0000001 ) {
                                        passed = true;
                                }
                }

        //      verify type     is the same
                if ( typeof(expect)     != typeof(actual) )     {
                        passed = false;
                }

                return passed;
}

/*
 * Begin printing functions.  These functions use the shell's
 * print function.  When running tests in the browser, these
 * functions, override these functions with functions that use
 * document.write.
 */

function writeTestCaseResult( expect, actual, string ) {
                var     passed = getTestCaseResult(     expect, actual );
                writeFormattedResult( expect, actual, string, passed );
                return passed;
}
function writeFormattedResult( expect, actual, string, passed ) {
        var s = string ;
        s += ( passed ) ? PASSED : FAILED + expect;
        writeLineToLog( s);
        return passed;
}
function writeLineToLog( string ) {
        print( string );
}
function writeHeaderToLog( string )     {
        print( string );
}
/* end of print functions */


/*
 * When running in the shell, run the garbage collector after the
 * test has completed.
 */

function stopTest()     {
        var gc;
        if ( gc != undefined ) {
                gc();
        }
}

/*
 * Convenience function for displaying failed test cases.  Useful
 * when running tests manually.
 *
 */
function getFailedCases() {
  for ( var     i =     0; i < testcases.length; i++ ) {
         if     ( !     testcases[i].passed     ) {
                print( testcases[i].description +" = " +testcases[i].actual     +" expected: "+ testcases[i].expect     );
         }
  }
}
 /*
  *     Date functions used     by tests in     Date suite
  *
  */
var     msPerDay =                      86400000;
var     HoursPerDay     =               24;
var     MinutesPerHour =        60;
var     SecondsPerMinute =      60;
var     msPerSecond     =               1000;
var     msPerMinute     =               60000;          //      msPerSecond     * SecondsPerMinute
var     msPerHour =                     3600000;        //      msPerMinute     * MinutesPerHour
var             TZ_DIFF = getTimeZoneDiff();  // offset of tester's timezone from UTC
var             TZ_PST = -8;  // offset of Pacific Standard Time from UTC
var             PST_DIFF = TZ_DIFF - TZ_PST;  // offset of tester's timezone from PST
var     TIME_1970        = 0;
var     TIME_2000        = 946684800000;
var     TIME_1900        = -2208988800000;
var     TIME_YEAR_0      = -62167219200000;


/*
 * Originally, the test suite used a hard-coded value TZ_DIFF = -8. 
 * But that was only valid for testers in the Pacific Standard Time Zone! 
 * We calculate the proper number dynamically for any tester. We just
 * have to be careful not to use a date subject to Daylight Savings Time...
*/
function getTimeZoneDiff()
{
  return -((new Date(2000, 1, 1)).getTimezoneOffset())/60;
}


/* 
 * Date test "ResultArrays" are hard-coded for Pacific Standard Time. 
 * We must adjust them for the tester's own timezone -
 */
function adjustResultArray(ResultArray, msMode)
{
  // If the tester's system clock is in PST, no need to continue - 
  if (!PST_DIFF) {return;} 

  /* The date testcases instantiate Date objects in two different ways:
   *
   *        millisecond mode: e.g.   dt = new Date(10000000);
   *        year-month-day mode:  dt = new Date(2000, 5, 1, ...);
   *
   * In the first case, the date is measured from Time 0 in Greenwich (i.e. UTC).
   * In the second case, it is measured with reference to the tester's local timezone.
   *
   * In the first case we must correct those values expected for local measurements,
   * like dt.getHours() etc. No correction is necessary for dt.getUTCHours() etc.
   * 
   * In the second case, it is exactly the other way around -
  */ 
  if (msMode)
  {
    // The hard-coded UTC milliseconds from Time 0 derives from a UTC date.
    // Shift to the right by the offset between UTC and the tester.
    var t = ResultArray[TIME]  +  TZ_DIFF*msPerHour;

    // Use our date arithmetic functions to determine the local hour, day, etc. 
    ResultArray[HOURS] = HourFromTime(t); 
    ResultArray[DAY] = WeekDay(t);
    ResultArray[DATE] = DateFromTime(t);
    ResultArray[MONTH] = MonthFromTime(t);
    ResultArray[YEAR] = YearFromTime(t);  
  }
  else
  {
    // The hard-coded UTC milliseconds from Time 0 derives from a PST date.
    // Shift to the left by the offset between PST and the tester.
    var t = ResultArray[TIME]  -  PST_DIFF*msPerHour;

    // Use our date arithmetic functions to determine the UTC hour, day, etc. 
    ResultArray[TIME] = t;
    ResultArray[UTC_HOURS] = HourFromTime(t); 
    ResultArray[UTC_DAY] = WeekDay(t);
    ResultArray[UTC_DATE] = DateFromTime(t);
    ResultArray[UTC_MONTH] = MonthFromTime(t);
    ResultArray[UTC_YEAR] = YearFromTime(t);
  }
}


function Day( t ) {
        return ( Math.floor(t/msPerDay ) );
}
function DaysInYear( y ) {
        if ( y % 4 != 0 ) {
                return 365;
        }
        if ( (y % 4     == 0) && (y     % 100 != 0)     ) {
                return 366;
        }
        if ( (y % 100 == 0)     &&      (y % 400 !=     0) ) {
                return 365;
        }
        if ( (y % 400 == 0)     ){
                return 366;
        } else {
                return "ERROR: DaysInYear("     + y     + ") case not covered";
        }
}
function TimeInYear( y ) {
        return ( DaysInYear(y) * msPerDay );
}
function DayNumber(     t )     {
        return ( Math.floor( t / msPerDay )     );
}
function TimeWithinDay( t )     {
        if ( t < 0 ) {
                return ( (t     % msPerDay)     + msPerDay );
        } else {
                return ( t % msPerDay );
        }
}
function YearNumber( t ) {
}
function TimeFromYear( y ) {
        return ( msPerDay *     DayFromYear(y) );
}
function DayFromYear( y ) {
        return (        365*(y-1970) +
                                Math.floor((y-1969)/4) -
                                Math.floor((y-1901)/100) +
                                Math.floor((y-1601)/400) );
}
function InLeapYear( t ) {
        if ( DaysInYear(YearFromTime(t)) ==     365     ) {
                return 0;
        }
        if ( DaysInYear(YearFromTime(t)) ==     366     ) {
                return 1;
        } else {
                return "ERROR:  InLeapYear("+ t + ") case not covered";
        }
}
function YearFromTime( t ) {
        t =     Number( t );
        var     sign = ( t < 0 ) ? -1 : 1;
        var     year = ( sign < 0 )     ? 1969 : 1970;
        for     (       var     timeToTimeZero = t;     ;  ) {
        //      subtract the current year's     time from the time that's left.
                timeToTimeZero -= sign * TimeInYear(year)

        //      if there's less than the current year's worth of time left,     then break.
                if ( sign <     0 )     {
                        if ( sign *     timeToTimeZero <= 0     ) {
                                break;
                        } else {
                                year += sign;
                        }
                } else {
                        if ( sign *     timeToTimeZero < 0 ) {
                                break;
                        } else {
                                year += sign;
                        }
                }
        }
        return ( year );
}
function MonthFromTime( t )     {
        //      i know i could use switch but i'd rather not until it's part of ECMA
        var     day     = DayWithinYear( t );
        var     leap = InLeapYear(t);

        if ( (0 <= day) && (day < 31) ) {
                return 0;
        }
        if ( (31 <=     day) && (day < (59+leap)) )     {
                return 1;
        }
        if ( ((59+leap) <= day) && (day < (90+leap)) ) {
                return 2;
        }
        if ( ((90+leap) <= day) && (day < (120+leap)) ) {
                return 3;
        }
        if ( ((120+leap) <=     day) && (day < (151+leap)) ) {
                return 4;
        }
        if ( ((151+leap) <=     day) && (day < (181+leap)) ) {
                return 5;
        }
        if ( ((181+leap) <=     day) && (day < (212+leap)) ) {
                return 6;
        }
        if ( ((212+leap) <=     day) && (day < (243+leap)) ) {
                return 7;
        }
        if ( ((243+leap) <=     day) && (day < (273+leap)) ) {
                return 8;
        }
        if ( ((273+leap) <=     day) && (day < (304+leap)) ) {
                return 9;
        }
        if ( ((304+leap) <=     day) && (day < (334+leap)) ) {
                return 10;
        }
        if ( ((334+leap) <=     day) && (day < (365+leap)) ) {
                return 11;
        } else {
                return "ERROR:  MonthFromTime("+t+") not known";
        }
}
function DayWithinYear( t )     {
                return( Day(t) - DayFromYear(YearFromTime(t)));
}
function DateFromTime( t ) {
        var     day     = DayWithinYear(t);
        var     month = MonthFromTime(t);

        if ( month == 0 ) {
                return ( day + 1 );
        }
        if ( month == 1 ) {
                return ( day - 30 );
        }
        if ( month == 2 ) {
                return ( day - 58 -     InLeapYear(t) );
        }
        if ( month == 3 ) {
                return ( day - 89 -     InLeapYear(t));
        }
        if ( month == 4 ) {
                return ( day - 119 - InLeapYear(t));
        }
        if ( month == 5 ) {
                return ( day - 150-     InLeapYear(t));
        }
        if ( month == 6 ) {
                return ( day - 180-     InLeapYear(t));
        }
        if ( month == 7 ) {
                return ( day - 211-     InLeapYear(t));
        }
        if ( month == 8 ) {
                return ( day - 242-     InLeapYear(t));
        }
        if ( month == 9 ) {
                return ( day - 272-     InLeapYear(t));
        }
        if ( month == 10 ) {
                return ( day - 303-     InLeapYear(t));
        }
        if ( month == 11 ) {
                return ( day - 333-     InLeapYear(t));
        }

        return ("ERROR:  DateFromTime("+t+") not known" );
}
function WeekDay( t     ) {
        var     weekday = (Day(t)+4) % 7;
        return( weekday < 0     ? 7     + weekday :     weekday );
}

// missing daylight     savins time     adjustment

function HourFromTime( t ) {
        var     h =     Math.floor(     t /     msPerHour )     % HoursPerDay;
        return ( (h<0) ? HoursPerDay + h : h  );
}
function MinFromTime( t ) {
        var     min     = Math.floor( t / msPerMinute ) % MinutesPerHour;
        return( ( min < 0 )     ? MinutesPerHour + min : min  );
}
function SecFromTime( t ) {
        var     sec     = Math.floor( t / msPerSecond ) % SecondsPerMinute;
        return ( (sec < 0 )     ? SecondsPerMinute + sec : sec );
}
function msFromTime( t ) {
        var     ms = t % msPerSecond;
        return ( (ms < 0 ) ? msPerSecond + ms : ms );
}
function LocalTZA()     {
        return ( TZ_DIFF * msPerHour );
}
function UTC( t ) {
        return ( t - LocalTZA() - DaylightSavingTA(t - LocalTZA()) );
}

function DaylightSavingTA( t ) {
        t =     t -     LocalTZA();

        var     dst_start = GetSecondSundayInMarch(t) + 2*msPerHour;
        var     dst_end   = GetFirstSundayInNovember(t)+ 2*msPerHour;

        if ( t >= dst_start     && t < dst_end ) {
                return msPerHour;
        } else {
                return 0;
        }

        // Daylight     Savings Time starts     on the first Sunday     in April at     2:00AM in
        // PST.  Other time     zones will need to override     this function.

        print( new Date( UTC(dst_start + LocalTZA())) );

        return UTC(dst_start  + LocalTZA());
}

function GetFirstSundayInApril( t ) {
    var year = YearFromTime(t);
    var leap = InLeapYear(t);

    var april = TimeFromYear(year) + TimeInMonth(0, leap) + TimeInMonth(1,leap) +
    TimeInMonth(2,leap);

    for ( var first_sunday = april; WeekDay(first_sunday) > 0;
        first_sunday += msPerDay )
    {
        ;
    }

    return first_sunday;
}
function GetLastSundayInOctober( t ) {
    var year = YearFromTime(t);
    var leap = InLeapYear(t);

    for ( var oct = TimeFromYear(year), m = 0; m < 9; m++ ) {
        oct += TimeInMonth(m, leap);
    }
    for ( var last_sunday = oct + 30*msPerDay; WeekDay(last_sunday) > 0;
        last_sunday -= msPerDay )
    {
        ;
    }
    return last_sunday;
}

// Added these two functions because DST rules changed for the US.
function GetSecondSundayInMarch( t ) {
        var     year = YearFromTime(t);
        var     leap = InLeapYear(t);

        var     march = TimeFromYear(year) + TimeInMonth(0, leap) + TimeInMonth(1,leap);

        var sundayCount = 0;
        var flag = true;
        for ( var second_sunday = march; flag; second_sunday += msPerDay )
        {
                if (WeekDay(second_sunday) == 0) {
                        if(++sundayCount == 2)
                                flag = false;
                }
        }

        return second_sunday;
}
function GetFirstSundayInNovember( t ) {
        var year = YearFromTime(t);
        var leap = InLeapYear(t);

        for ( var nov = TimeFromYear(year), m = 0; m < 10; m++ ) {
                nov += TimeInMonth(m, leap);
        }
        for ( var first_sunday = nov; WeekDay(first_sunday) > 0;
                first_sunday += msPerDay        )
        {
                ;
        }
        return first_sunday;
}
function LocalTime(     t )     {
        return ( t + LocalTZA() + DaylightSavingTA(t) );
}
function MakeTime( hour, min, sec, ms ) {
        if ( isNaN(     hour ) || isNaN( min ) || isNaN( sec ) || isNaN( ms     ) )     {
                return Number.NaN;
        }

        hour = ToInteger(hour);
        min      = ToInteger( min);
        sec      = ToInteger( sec);
        ms       = ToInteger( ms );

        return( (hour*msPerHour) + (min*msPerMinute) +
                        (sec*msPerSecond) +     ms );
}
function MakeDay( year, month, date     ) {
        if ( isNaN(year) ||     isNaN(month) || isNaN(date)     ) {
                return Number.NaN;
        }
        year = ToInteger(year);
        month = ToInteger(month);
        date = ToInteger(date );

        var     sign = ( year < 1970 ) ? -1     : 1;
        var     t =        ( year <     1970 ) ? 1 :  0;
        var     y =        ( year <     1970 ) ? 1969 : 1970;

        var     result5 = year + Math.floor( month/12 );
        var     result6 = month % 12;

        if ( year <     1970 ) {
           for ( y = 1969; y >= year; y += sign ) {
                 t += sign * TimeInYear(y);
           }
        } else {
                for     ( y     = 1970 ; y < year; y += sign ) {
                        t += sign *     TimeInYear(y);
                }
        }

        var     leap = InLeapYear( t );

        for     ( var m = 0; m < month; m++     ) {
                t += TimeInMonth( m, leap );
        }

        if ( YearFromTime(t) != result5 ) {
                return Number.NaN;
        }
        if ( MonthFromTime(t) != result6 ) {
                return Number.NaN;
        }
        if ( DateFromTime(t) != 1 )     {
                return Number.NaN;
        }

        return ( (Day(t)) +     date - 1 );
}
function TimeInMonth( month, leap )     {
        // september april june november
        // jan 0  feb 1  mar 2  apr     3       may     4  june 5  jul 6
        // aug 7  sep 8  oct 9  nov     10      dec     11

        if ( month == 3 || month ==     5 || month == 8 || month ==     10 ) {
                return ( 30*msPerDay );
        }

        // all the rest
        if ( month == 0 || month ==     2 || month == 4 || month ==     6 ||
                 month == 7     || month ==     9 || month == 11 ) {
                return ( 31*msPerDay );
         }

        // save february
        return ( (leap == 0) ? 28*msPerDay : 29*msPerDay );
}
function MakeDate( day, time ) {
        if (    day     == Number.POSITIVE_INFINITY     ||
                        day     == Number.NEGATIVE_INFINITY     ||
                        day     == Number.NaN ) {
                return Number.NaN;
        }
        if (    time == Number.POSITIVE_INFINITY ||
                        time == Number.POSITIVE_INFINITY ||
                        day     == Number.NaN) {
                return Number.NaN;
        }
        return ( day * msPerDay ) +     time;
}
function TimeClip( t ) {
        if ( isNaN(     t )     ) {
                return ( Number.NaN     );
        }
        if ( Math.abs( t ) > 8.64e15 ) {
                return ( Number.NaN     );
        }

        return ( ToInteger(     t )     );
}
function ToInteger(     t )     {
        t =     Number( t );

        if ( isNaN(     t )     ){
                return ( Number.NaN     );
        }
        if ( t == 0     || t == -0 ||
                 t == Number.POSITIVE_INFINITY || t     == Number.NEGATIVE_INFINITY     ) {
                 return 0;
        }

        var     sign = ( t < 0 ) ? -1 : 1;

        return ( sign * Math.floor(     Math.abs( t     ) )     );
}
function Enumerate ( o ) {
        var     p;
        for     ( p     in o ) {
                print( p +": " + o[p] );
        }
}

/* these functions are useful for running tests manually in Rhino */

function GetContext() {
        return Packages.com.netscape.javascript.Context.getCurrentContext();
}
function OptLevel( i ) {
        i =     Number(i);
        var     cx = GetContext();
        cx.setOptimizationLevel(i);
}
/* end of Rhino functions */