sebastienros.jint/Jint.Tests.Ecma/TestCases/sta.js

/// Copyright (c) 2012 Ecma International.  All rights reserved. 
/// Ecma International makes this code available under the terms and conditions set
/// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
/// "Use Terms").   Any redistribution of this code must retain the above 
/// copyright and this notice and otherwise comply with the Use Terms.

//-----------------------------------------------------------------------------
function compareArray(aExpected, aActual) {
    if (aActual.length != aExpected.length) {
        return false;
    }

    aExpected.sort();
    aActual.sort();

    var s;
    for (var i = 0; i < aExpected.length; i++) {
        if (aActual[i] !== aExpected[i]) {
            return false;
        }
    }
    return true;
}

//-----------------------------------------------------------------------------
function arrayContains(arr, expected) {
    var found;
    for (var i = 0; i < expected.length; i++) {
        found = false;
        for (var j = 0; j < arr.length; j++) {
            if (expected[i] === arr[j]) {
                found = true;
                break;
            }
        }
        if (!found) {
            return false;
        }
    }
    return true;
}

//-----------------------------------------------------------------------------
var supportsArrayIndexGettersOnArrays = undefined;
function fnSupportsArrayIndexGettersOnArrays() {
    if (typeof supportsArrayIndexGettersOnArrays !== "undefined") {
        return supportsArrayIndexGettersOnArrays;
    }

    supportsArrayIndexGettersOnArrays = false;

    if (fnExists(Object.defineProperty)) {
        var arr = [];
        Object.defineProperty(arr, "0", {
            get: function () {
                supportsArrayIndexGettersOnArrays = true;
                return 0;
            }
        });
        var res = arr[0];
    }

    return supportsArrayIndexGettersOnArrays;
}

//-----------------------------------------------------------------------------
var supportsArrayIndexGettersOnObjects = undefined;
function fnSupportsArrayIndexGettersOnObjects() {
    if (typeof supportsArrayIndexGettersOnObjects !== "undefined")
        return supportsArrayIndexGettersOnObjects;

    supportsArrayIndexGettersOnObjects = false;

    if (fnExists(Object.defineProperty)) {
        var obj = {};
        Object.defineProperty(obj, "0", {
            get: function () {
                supportsArrayIndexGettersOnObjects = true;
                return 0;
            }
        });
        var res = obj[0];
    }

    return supportsArrayIndexGettersOnObjects;
}

//-----------------------------------------------------------------------------
function ConvertToFileUrl(pathStr) {
    return "file:" + pathStr.replace(/\\/g, "/");
}

//-----------------------------------------------------------------------------
function fnExists(/*arguments*/) {
    for (var i = 0; i < arguments.length; i++) {
        if (typeof (arguments[i]) !== "function") return false;
    }
    return true;
}

//-----------------------------------------------------------------------------
var __globalObject = Function("return this;")();
function fnGlobalObject() {
    return __globalObject;
}

//-----------------------------------------------------------------------------
function fnSupportsStrict() {
    "use strict";
    try {
        eval('with ({}) {}');
        return false;
    } catch (e) {
        return true;
    }
}

//-----------------------------------------------------------------------------
//Verify all attributes specified data property of given object:
//value, writable, enumerable, configurable
//If all attribute values are expected, return true, otherwise, return false
function dataPropertyAttributesAreCorrect(obj,
                                          name,
                                          value,
                                          writable,
                                          enumerable,
                                          configurable) {
    var attributesCorrect = true;

    if (obj[name] !== value) {
        if (typeof obj[name] === "number" &&
            isNaN(obj[name]) &&
            typeof value === "number" &&
            isNaN(value)) {
            // keep empty
        } else {
            attributesCorrect = false;
        }
    }

    try {
        if (obj[name] === "oldValue") {
            obj[name] = "newValue";
        } else {
            obj[name] = "OldValue";
        }
    } catch (we) {
    }

    var overwrited = false;
    if (obj[name] !== value) {
        if (typeof obj[name] === "number" &&
            isNaN(obj[name]) &&
            typeof value === "number" &&
            isNaN(value)) {
            // keep empty
        } else {
            overwrited = true;
        }
    }
    if (overwrited !== writable) {
        attributesCorrect = false;
    }

    var enumerated = false;
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop) && prop === name) {
            enumerated = true;
        }
    }

    if (enumerated !== enumerable) {
        attributesCorrect = false;
    }


    var deleted = false;

    try {
        delete obj[name];
    } catch (de) {
    }
    if (!obj.hasOwnProperty(name)) {
        deleted = true;
    }
    if (deleted !== configurable) {
        attributesCorrect = false;
    }

    return attributesCorrect;
}

//-----------------------------------------------------------------------------
//Verify all attributes specified accessor property of given object:
//get, set, enumerable, configurable
//If all attribute values are expected, return true, otherwise, return false
function accessorPropertyAttributesAreCorrect(obj,
                                              name,
                                              get,
                                              set,
                                              setVerifyHelpProp,
                                              enumerable,
                                              configurable) {
    var attributesCorrect = true;

    if (get !== undefined) {
        if (obj[name] !== get()) {
            if (typeof obj[name] === "number" &&
                isNaN(obj[name]) &&
                typeof get() === "number" &&
                isNaN(get())) {
                // keep empty
            } else {
                attributesCorrect = false;
            }
        }
    } else {
        if (obj[name] !== undefined) {
            attributesCorrect = false;
        }
    }

    try {
        var desc = Object.getOwnPropertyDescriptor(obj, name);
        if (typeof desc.set === "undefined") {
            if (typeof set !== "undefined") {
                attributesCorrect = false;
            }
        } else {
            obj[name] = "toBeSetValue";
            if (obj[setVerifyHelpProp] !== "toBeSetValue") {
                attributesCorrect = false;
            }
        }
    } catch (se) {
        throw se;
    }


    var enumerated = false;
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop) && prop === name) {
            enumerated = true;
        }
    }

    if (enumerated !== enumerable) {
        attributesCorrect = false;
    }


    var deleted = false;
    try {
        delete obj[name];
    } catch (de) {
        throw de;
    }
    if (!obj.hasOwnProperty(name)) {
        deleted = true;
    }
    if (deleted !== configurable) {
        attributesCorrect = false;
    }

    return attributesCorrect;
}

//-----------------------------------------------------------------------------
var NotEarlyErrorString = "NotEarlyError";
var EarlyErrorRePat = "^((?!" + NotEarlyErrorString + ").)*$";
var NotEarlyError = new Error(NotEarlyErrorString);

//-----------------------------------------------------------------------------
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

function Test262Error(message) {
    if (message) this.message = message;
}

Test262Error.prototype.toString = function () {
    return "Test262 Error: " + this.message;
};

function testFailed(message) {
    throw new Test262Error(message);
}


function testPrint(message) {

}


//adaptors for Test262 framework
function $PRINT(message) {

}

function $INCLUDE(message) { }
function $ERROR(message) {
    testFailed(message);
}

function $FAIL(message) {
    testFailed(message);
}



//Sputnik library definitions
//Ultimately these should be namespaced some how and only made
//available to tests that explicitly include them.
//For now, we just define the globally

//math_precision.js
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

function getPrecision(num) {
    //TODO: Create a table of prec's,
    //      because using Math for testing Math isn't that correct.

    var log2num = Math.log(Math.abs(num)) / Math.LN2;
    var pernum = Math.ceil(log2num);
    return (2 * Math.pow(2, -52 + pernum));
    //return(0);
}


//math_isequal.js
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

var prec;
function isEqual(num1, num2) {
    if ((num1 === Infinity) && (num2 === Infinity)) {
        return (true);
    }
    if ((num1 === -Infinity) && (num2 === -Infinity)) {
        return (true);
    }
    prec = getPrecision(Math.min(Math.abs(num1), Math.abs(num2)));
    return (Math.abs(num1 - num2) <= prec);
    //return(num1 === num2);
}

//numeric_conversion.js
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

function ToInteger(p) {
    var x = Number(p);

    if (isNaN(x)) {
        return +0;
    }

    if ((x === +0)
  || (x === -0)
  || (x === Number.POSITIVE_INFINITY)
  || (x === Number.NEGATIVE_INFINITY)) {
        return x;
    }

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

    return (sign * Math.floor(Math.abs(x)));
}

//Date_constants.js
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

var HoursPerDay = 24;
var MinutesPerHour = 60;
var SecondsPerMinute = 60;

var msPerDay = 86400000;
var msPerSecond = 1000;
var msPerMinute = 60000;
var msPerHour = 3600000;

var date_1899_end = -2208988800001;
var date_1900_start = -2208988800000;
var date_1969_end = -1;
var date_1970_start = 0;
var date_1999_end = 946684799999;
var date_2000_start = 946684800000;
var date_2099_end = 4102444799999;
var date_2100_start = 4102444800000;

// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

//the following values are normally generated by the sputnik.py driver
var $LocalTZ,
    $DST_start_month,
    $DST_start_sunday,
    $DST_start_hour,
    $DST_start_minutes,
    $DST_end_month,
    $DST_end_sunday,
    $DST_end_hour,
    $DST_end_minutes;

(function () {
    /**
      * Finds the first date, starting from |start|, where |predicate|
      * holds.
      */
    var findNearestDateBefore = function (start, predicate) {
        var current = start;
        var month = 1000 * 60 * 60 * 24 * 30;
        for (var step = month; step > 0; step = Math.floor(step / 3)) {
            if (!predicate(current)) {
                while (!predicate(current))
                    current = new Date(current.getTime() + step);
                current = new Date(current.getTime() - step);
            }
        }
        while (!predicate(current)) {
            current = new Date(current.getTime() + 1);
        }
        return current;
    };

    var juneDate = new Date(2000, 5, 20, 0, 0, 0, 0);
    var decemberDate = new Date(2000, 11, 20, 0, 0, 0, 0);
    var juneOffset = juneDate.getTimezoneOffset();
    var decemberOffset = decemberDate.getTimezoneOffset();
    var isSouthernHemisphere = (juneOffset > decemberOffset);
    var winterTime = isSouthernHemisphere ? juneDate : decemberDate;
    var summerTime = isSouthernHemisphere ? decemberDate : juneDate;

    var dstStart = findNearestDateBefore(winterTime, function (date) {
        return date.getTimezoneOffset() == summerTime.getTimezoneOffset();
    });
    $DST_start_month = dstStart.getMonth();
    $DST_start_sunday = dstStart.getDate() > 15 ? '"last"' : '"first"';
    $DST_start_hour = dstStart.getHours();
    $DST_start_minutes = dstStart.getMinutes();

    var dstEnd = findNearestDateBefore(summerTime, function (date) {
        return date.getTimezoneOffset() == winterTime.getTimezoneOffset();
    });
    $DST_end_month = dstEnd.getMonth();
    $DST_end_sunday = dstEnd.getDate() > 15 ? '"last"' : '"first"';
    $DST_end_hour = dstEnd.getHours();
    $DST_end_minutes = dstEnd.getMinutes();

    return;
})();


//Date.library.js
// Copyright 2009 the Sputnik authors.  All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.

//15.9.1.2 Day Number and Time within Day
function Day(t) {
    return Math.floor(t / msPerDay);
}

function TimeWithinDay(t) {
    return t % msPerDay;
}

//15.9.1.3 Year Number
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;
}

function DayFromYear(y) {
    return (365 * (y - 1970)
            + Math.floor((y - 1969) / 4)
            - Math.floor((y - 1901) / 100)
            + Math.floor((y - 1601) / 400));
}

function TimeFromYear(y) {
    return msPerDay * DayFromYear(y);
}

function YearFromTime(t) {
    t = Number(t);
    var sign = (t < 0) ? -1 : 1;
    var year = (sign < 0) ? 1969 : 1970;

    for (var time = 0; ; year += sign) {
        time = TimeFromYear(year);

        if (sign > 0 && time > t) {
            year -= sign;
            break;
        }
        else if (sign < 0 && time <= t) {
            break;
        }
    };
    return year;
}

function InLeapYear(t) {
    if (DaysInYear(YearFromTime(t)) == 365)
        return 0;

    if (DaysInYear(YearFromTime(t)) == 366)
        return 1;
}

function DayWithinYear(t) {
    return Day(t) - DayFromYear(YearFromTime(t));
}

//15.9.1.4 Month Number
function MonthFromTime(t) {
    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;
}

//15.9.1.5 Date Number
function DateFromTime(t) {
    var day = DayWithinYear(t);
    var month = MonthFromTime(t);
    var leap = InLeapYear(t);

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

//15.9.1.6 Week Day
function WeekDay(t) {
    var weekday = (Day(t) + 4) % 7;
    return (weekday < 0 ? 7 + weekday : weekday);
}

//15.9.1.9 Daylight Saving Time Adjustment
$LocalTZ = (new Date()).getTimezoneOffset() / -60;
if (DaylightSavingTA((new Date()).valueOf()) !== 0) {
    $LocalTZ -= 1;
}
var LocalTZA = $LocalTZ * msPerHour;

function DaysInMonth(m, leap) {
    m = m % 12;

    //April, June, Sept, Nov
    if (m == 3 || m == 5 || m == 8 || m == 10) {
        return 30;
    }

    //Jan, March, May, July, Aug, Oct, Dec
    if (m == 0 || m == 2 || m == 4 || m == 6 || m == 7 || m == 9 || m == 11) {
        return 31;
    }

    //Feb
    return 28 + leap;
}

function GetSundayInMonth(t, m, count) {
    var year = YearFromTime(t);
    var tempDate;

    if (count === '"first"') {
        for (var d = 1; d <= DaysInMonth(m, InLeapYear(t)) ; d++) {
            tempDate = new Date(year, m, d);
            if (tempDate.getDay() === 0) {
                return tempDate.valueOf();
            }
        }
    } else if (count === '"last"') {
        for (var d = DaysInMonth(m, InLeapYear(t)) ; d > 0; d--) {
            tempDate = new Date(year, m, d);
            if (tempDate.getDay() === 0) {
                return tempDate.valueOf();
            }
        }
    }
    throw new Error("Unsupported 'count' arg:" + count);
}
/*
function GetSundayInMonth(t, m, count){
  var year = YearFromTime(t);
  var leap = InLeapYear(t);
  var day = 0;

  if(m >= 1) day += DaysInMonth(0, leap);
  if(m >= 2) day += DaysInMonth(1, leap);
  if(m >= 3) day += DaysInMonth(2, leap);
  if(m >= 4) day += DaysInMonth(3, leap);
  if(m >= 5) day += DaysInMonth(4, leap);
  if(m >= 6) day += DaysInMonth(5, leap);
  if(m >= 7) day += DaysInMonth(6, leap);
  if(m >= 8) day += DaysInMonth(7, leap);
  if(m >= 9) day += DaysInMonth(8, leap);
  if(m >= 10) day += DaysInMonth(9, leap);
  if(m >= 11) day += DaysInMonth(10, leap);

  var month_start = TimeFromYear(year)+day*msPerDay;
  var sunday = 0;

  if(count === "last"){
    for(var last_sunday = month_start+DaysInMonth(m, leap)*msPerDay;
      WeekDay(last_sunday)>0;
      last_sunday -= msPerDay
    ){};
    sunday = last_sunday;
  }
  else {
    for(var first_sunday = month_start;
      WeekDay(first_sunday)>0;
      first_sunday += msPerDay
    ){};
    sunday = first_sunday+7*msPerDay*(count-1);
  }

  return sunday;
}*/

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

    var DST_start = GetSundayInMonth(t, $DST_start_month, $DST_start_sunday) +
                    $DST_start_hour * msPerHour +
                    $DST_start_minutes * msPerMinute;

    var k = new Date(DST_start);

    var DST_end = GetSundayInMonth(t, $DST_end_month, $DST_end_sunday) +
                    $DST_end_hour * msPerHour +
                    $DST_end_minutes * msPerMinute;

    if (t >= DST_start && t < DST_end) {
        return msPerHour;
    } else {
        return 0;
    }
}

//15.9.1.9 Local Time
function LocalTime(t) {
    return t + LocalTZA + DaylightSavingTA(t);
}

function UTC(t) {
    return t - LocalTZA - DaylightSavingTA(t - LocalTZA);
}

//15.9.1.10 Hours, Minutes, Second, and Milliseconds
function HourFromTime(t) {
    return Math.floor(t / msPerHour) % HoursPerDay;
}

function MinFromTime(t) {
    return Math.floor(t / msPerMinute) % MinutesPerHour;
}

function SecFromTime(t) {
    return Math.floor(t / msPerSecond) % SecondsPerMinute;
}

function msFromTime(t) {
    return t % msPerSecond;
}

//15.9.1.11 MakeTime (hour, min, sec, ms)
function MakeTime(hour, min, sec, ms) {
    if (!isFinite(hour) || !isFinite(min) || !isFinite(sec) || !isFinite(ms)) {
        return Number.NaN;
    }

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

    return ((hour * msPerHour) + (min * msPerMinute) + (sec * msPerSecond) + ms);
}

//15.9.1.12 MakeDay (year, month, date)
function MakeDay(year, month, date) {
    if (!isFinite(year) || !isFinite(month) || !isFinite(date)) {
        return Number.NaN;
    }

    year = ToInteger(year);
    month = ToInteger(month);
    date = ToInteger(date);

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

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

    if (sign == -1) {
        for (y = 1969; y >= year; y += sign) {
            t += sign * DaysInYear(y) * msPerDay;
        }
    } else {
        for (y = 1970 ; y < year; y += sign) {
            t += sign * DaysInYear(y) * msPerDay;
        }
    }

    var leap = 0;
    for (var m = 0; m < month; m++) {
        //if year is changed, than we need to recalculate leep
        leap = InLeapYear(t);
        t += DaysInMonth(m, leap) * msPerDay;
    }

    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;
}

//15.9.1.13 MakeDate (day, time)
function MakeDate(day, time) {
    if (!isFinite(day) || !isFinite(time)) {
        return Number.NaN;
    }

    return day * msPerDay + time;
}

//15.9.1.14 TimeClip (time)
function TimeClip(time) {
    if (!isFinite(time) || Math.abs(time) > 8.64e15) {
        return Number.NaN;
    }

    return ToInteger(time);
}

//Test Functions
//ConstructDate is considered deprecated, and should not be used directly from
//test262 tests as it's incredibly sensitive to DST start/end dates that 
//vary with geographic location.
function ConstructDate(year, month, date, hours, minutes, seconds, ms) {
    /*
     * 1. Call ToNumber(year)
     * 2. Call ToNumber(month)
     * 3. If date is supplied use ToNumber(date); else use 1
     * 4. If hours is supplied use ToNumber(hours); else use 0
     * 5. If minutes is supplied use ToNumber(minutes); else use 0
     * 6. If seconds is supplied use ToNumber(seconds); else use 0
     * 7. If ms is supplied use ToNumber(ms); else use 0
     * 8. If Result(1) is not NaN and 0 <= ToInteger(Result(1)) <= 99, Result(8) is
     * 1900+ToInteger(Result(1)); otherwise, Result(8) is Result(1)
     * 9. Compute MakeDay(Result(8), Result(2), Result(3))
     * 10. Compute MakeTime(Result(4), Result(5), Result(6), Result(7))
     * 11. Compute MakeDate(Result(9), Result(10))
     * 12. Set the [[Value]] property of the newly constructed object to TimeClip(UTC(Result(11)))
     */
    var r1 = Number(year);
    var r2 = Number(month);
    var r3 = ((date && arguments.length > 2) ? Number(date) : 1);
    var r4 = ((hours && arguments.length > 3) ? Number(hours) : 0);
    var r5 = ((minutes && arguments.length > 4) ? Number(minutes) : 0);
    var r6 = ((seconds && arguments.length > 5) ? Number(seconds) : 0);
    var r7 = ((ms && arguments.length > 6) ? Number(ms) : 0);

    var r8 = r1;

    if (!isNaN(r1) && (0 <= ToInteger(r1)) && (ToInteger(r1) <= 99))
        r8 = 1900 + r1;

    var r9 = MakeDay(r8, r2, r3);
    var r10 = MakeTime(r4, r5, r6, r7);
    var r11 = MakeDate(r9, r10);

    var retVal = TimeClip(UTC(r11));
    return retVal;
}



/**** Python code for initialize the above constants
// We may want to replicate the following in JavaScript.
// However, using JS date operations to generate parameters that are then used to
// test those some date operations seems unsound.  However, it isn't clear if there
//is a good interoperable alternative.

# Copyright 2009 the Sputnik authors.  All rights reserved.
# This code is governed by the BSD license found in the LICENSE file.

def GetDaylightSavingsTimes():
# Is the given floating-point time in DST?
def IsDst(t):
return time.localtime(t)[-1]
# Binary search to find an interval between the two times no greater than
# delta where DST switches, returning the midpoint.
def FindBetween(start, end, delta):
while end - start > delta:
middle = (end + start) / 2
if IsDst(middle) == IsDst(start):
start = middle
else:
end = middle
return (start + end) / 2
now = time.time()
one_month = (30 * 24 * 60 * 60)
# First find a date with different daylight savings.  To avoid corner cases
# we try four months before and after today.
after = now + 4 * one_month
before = now - 4 * one_month
if IsDst(now) == IsDst(before) and IsDst(now) == IsDst(after):
logger.warning("Was unable to determine DST info.")
return None
# Determine when the change occurs between now and the date we just found
# in a different DST.
if IsDst(now) != IsDst(before):
first = FindBetween(before, now, 1)
else:
first = FindBetween(now, after, 1)
# Determine when the change occurs between three and nine months from the
# first.
second = FindBetween(first + 3 * one_month, first + 9 * one_month, 1)
# Find out which switch is into and which if out of DST
if IsDst(first - 1) and not IsDst(first + 1):
start = second
end = first
else:
start = first
end = second
return (start, end)


def GetDaylightSavingsAttribs():
times = GetDaylightSavingsTimes()
if not times:
return None
(start, end) = times
def DstMonth(t):
return time.localtime(t)[1] - 1
def DstHour(t):
return time.localtime(t - 1)[3] + 1
def DstSunday(t):
if time.localtime(t)[2] > 15:
return "'last'"
else:
return "'first'"
def DstMinutes(t):
return (time.localtime(t - 1)[4] + 1) % 60
attribs = { }
attribs['start_month'] = DstMonth(start)
attribs['end_month'] = DstMonth(end)
attribs['start_sunday'] = DstSunday(start)
attribs['end_sunday'] = DstSunday(end)
attribs['start_hour'] = DstHour(start)
attribs['end_hour'] = DstHour(end)
attribs['start_minutes'] = DstMinutes(start)
attribs['end_minutes'] = DstMinutes(end)
return attribs

*********/

//--Test case registration-----------------------------------------------------
function runTestCase(testcase) {
    if (testcase() !== true) {
        $ERROR("Test case returned non-true value!");
    }
}