########################################################################
# $Header: /var/local/cvsroot/4Suite/test/Xml/Xslt/Exslt/test_datetime.py,v 1.2 2006/01/04 16:00:55 jkloth Exp $
"""Tests for EXSLT Dates and Times"""

import re

from Ft.Lib import boolean, number
from Ft.Xml.Xslt.Exslt import DateTime

DATE = r'-?[0-9]{4,}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[01])'
TIME = r'[012]\d:[0-5]\d:[0-6]\d'
DATETIME = DATE + 'T' + TIME
TZ = r'(Z|[-+][0-9]{2}:[0-9]{2})?'
DATE += TZ
TIME += TZ
DATETIME += TZ

TESTS = []

# date:date-time()
def test_DateTime(tester):
    tester.startTest('date:date-time() syntax')
    result = DateTime.DateTime(None)
    tester.compare(True, re.search('^%s$' % DATETIME, result) is not None,
                   'Result %r does not match regexp %r' % (result, DATETIME))
    tester.testDone()
    return
TESTS.append(test_DateTime)


# date:date()
def test_Date(tester):
    tester.startTest('date:date() syntax')
    result = DateTime.Date(None)
    tester.compare(True, re.search('^%s$' % DATE, result) is not None,
                   'Result %r does not match regexp %r' % (result, DATE))
    tester.testDone()

    dates = [
        (u'2003-09-12T23:59:59-0400', u''),     # RFC822 TZ format bad!
        (u'2003-09-12T23:59:59-04:00', u'2003-09-12-04:00'),
        # TZ on input, MUST have TZ on output
        (u'2001-01-01T00:00:00Z', u'2001-01-01Z'),
        # no TZ on input, MUST NOT have TZ on output
        (u'2000-01-01T00:00:00', u'2000-01-01'),
        (u'2005-05-05', u'2005-05-05'),
        (u'Jan 01, 2001', u''),
        #(u'2005-05-05+0100', u'2005-05-05+0100'), # tz in = tz out? spec unclear
        ]
    for source, expected in dates:
        tester.startTest("date:date('%s')" % source)
        result = DateTime.Date(None, source)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Date)


# date:time()
def test_Time(tester):
    tester.startTest('date:time() syntax')
    result = DateTime.Time(None)
    tester.compare(True, re.search('^%s$' % TIME, result) is not None,
                   'Result %r does not match regexp %r' % (result, TIME))
    tester.testDone()

    times = [
        (u'2003-09-12T23:59:59-0400', u''),     # RFC822 format TZ bad!
        (u'2003-09-12T23:59:59-04:00', u'23:59:59-04:00'),
        # TZ on input, MUST have TZ on output
        (u'2001-01-01T00:00:00Z', u'00:00:00Z'),
        # no TZ on input, MUST NOT have TZ on output
        (u'2000-01-01T00:00:00', u'00:00:00'),
        (u'00:00:00', u'00:00:00'), # xs:date input good!
        (u'T00:00:00', u''),        # ISO 8601 date input bad!
        (u'02:22:22 PM', u''),
        ]
    for time, expected in times:
        tester.startTest("date:time('%s')" % time)
        result = DateTime.Time(None, time)
        if isinstance(expected, list):
            tester.compareIn(expected, result)
        else:
            tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Time)


# date:year()
def test_Year(tester):
    tests = [
        (u'2003-09-12T23:59:59-04:00', 2003),
        (u'2001-01-01', 2001),
        (u'2000-01', 2000),
        (u'1999', 1999)
        ]
    for datetime, expected in tests:
        tester.startTest("date:year('%s')" % datetime)
        result = DateTime.Year(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Year)


# date:leap-year()
def test_LeapYear(tester):
    tests = [
        (u'2004-09-12T23:59:59-04:00', boolean.true),
        (u'2000-01-01', boolean.true),
        (u'1900', boolean.false),
        (u'3000', boolean.false)
        ]
    for datetime, expected in tests:
        tester.startTest("date:leap-year('%s')" % datetime)
        result = DateTime.LeapYear(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_LeapYear)


# date:month-in-year()
def test_MonthInYear(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 5),      # xs:dateTime
        (u'2002-05-09T19:00:00Z', 5),           # xs:dateTime
        (u'2002-11-09T19:00:00', 11),           # xs:dateTime
        (u'2002-03-10+13:00', 3),               # xs:date
        (u'2002-06-09-11:00', 6),               # xs:date
        (u'2002-02-08', 2),                     # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', 12),                      # xs:gYearMonth
        (u'1999-04', 4),                        # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', 8),                  # xs:gMonthDay
        (u'--09-14', 9),                        # xs:gMonthDay
        (u'--07-11:00', 7),                     # xs:gMonth
        (u'--10', 10),                          # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:month-in-year('%s')" % datetime)
        result = DateTime.MonthInYear(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_MonthInYear)


# date:month-name()
def test_MonthName(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', u'May'), # xs:dateTime
        (u'2002-05-09T19:00:00Z', u'May'),      # xs:dateTime
        (u'2002-11-09T19:00:00', u'November'),  # xs:dateTime
        (u'2002-03-10+13:00', u'March'),        # xs:date
        (u'2002-06-09-11:00', u'June'),         # xs:date
        (u'2002-04-08', u'April'),              # xs:date
        (u'12:20:00-05:00', u''),               # xs:time
        (u'17:20:00Z', u''),                    # xs:time
        (u'24:00:00', u''),                     # xs:time
        (u'1999-12Z', u'December'),             # xs:gYearMonth
        (u'1999-04', u'April'),                 # xs:gYearMonth
        (u'1999-07:00', u''),                   # xs:gYear
        (u'1999', u''),                         # xs:gYear
        (u'--08-14+14:00', u'August'),          # xs:gMonthDay
        (u'--09-14', u'September'),             # xs:gMonthDay
        (u'--07-11:00', u'July'),               # xs:gMonth
        (u'--10', u'October'),                  # xs:gMonth
        (u'---05Z', u''),                       # xs:gDay
        (u'---09', u''),                        # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:month-name('%s')" % datetime)
        result = DateTime.MonthName(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_MonthName)


# date:month-abbreviation()
def test_MonthAbbreviation(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', u'May'), # xs:dateTime
        (u'2002-05-09T19:00:00Z', u'May'),      # xs:dateTime
        (u'2002-11-09T19:00:00', u'Nov'),       # xs:dateTime
        (u'2002-03-10+13:00', u'Mar'),          # xs:date
        (u'2002-06-09-11:00', u'Jun'),          # xs:date
        (u'2002-04-08', u'Apr'),                # xs:date
        (u'12:20:00-05:00', u''),               # xs:time
        (u'17:20:00Z', u''),                    # xs:time
        (u'24:00:00', u''),                     # xs:time
        (u'1999-12Z', u'Dec'),                  # xs:gYearMonth
        (u'1999-04', u'Apr'),                   # xs:gYearMonth
        (u'1999-07:00', u''),                   # xs:gYear
        (u'1999', u''),                         # xs:gYear
        (u'--08-14+14:00', u'Aug'),             # xs:gMonthDay
        (u'--09-14', u'Sep'),                   # xs:gMonthDay
        (u'--07-11:00', u'Jul'),                # xs:gMonth
        (u'--10', u'Oct'),                      # xs:gMonth
        (u'---05Z', u''),                       # xs:gDay
        (u'---09', u''),                        # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:month-abbreviation('%s')" % datetime)
        result = DateTime.MonthAbbreviation(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_MonthAbbreviation)


# date:week-in-year()
def test_WeekInYear(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 19),     # xs:dateTime
        (u'2002-05-09T19:00:00Z', 19),          # xs:dateTime
        (u'2002-11-09T19:00:00', 45),           # xs:dateTime
        (u'2002-03-10+13:00', 10),              # xs:date
        (u'2002-06-09-11:00', 23),              # xs:date
        (u'2002-04-08', 15),                    # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        # test case some edge cases
        (u'1969-12-30', 1),
        (u'1971-01-01', 53),
        (u'1979-12-31', 1),
        (u'1984-01-01', 52),
        (u'1991-12-30', 1),
        (u'1999-01-03', 53),
        (u'2012-12-31', 1),
        (u'2017-01-01', 52),
        (u'2029-01-01', 1),
        ]
    for datetime, expected in tests:
        tester.startTest("date:month-in-year('%s')" % datetime)
        result = DateTime.WeekInYear(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_WeekInYear)


# date:day-in-year()
def test_DayInYear(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 130),    # xs:dateTime
        (u'2002-05-09T19:00:00Z', 129),         # xs:dateTime
        (u'2002-11-09T19:00:00', 313),          # xs:dateTime
        (u'2002-03-10+13:00', 69),              # xs:date
        (u'2002-06-09-11:00', 160),             # xs:date
        (u'2002-04-08', 98),                    # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:day-in-year('%s')" % datetime)
        result = DateTime.DayInYear(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_DayInYear)


# date:day-in-month()
def test_DayInMonth(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 10),     # xs:dateTime
        (u'2002-05-09T19:00:00Z', 9),           # xs:dateTime
        (u'2002-11-09T19:00:00', 9),            # xs:dateTime
        (u'2002-03-10+13:00', 10),              # xs:date
        (u'2002-06-09-11:00', 9),               # xs:date
        (u'2002-04-08', 8),                     # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', 14),                 # xs:gMonthDay
        (u'--09-14', 14),                       # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', 5),                         # xs:gDay
        (u'---09', 9),                          # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:day-in-month('%s')" % datetime)
        result = DateTime.DayInMonth(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_DayInMonth)


# date:day-of-week-in-month()
def test_DayOfWeekInMonth(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 2),      # xs:dateTime
        (u'2002-05-09T19:00:00Z', 2),           # xs:dateTime
        (u'2002-11-09T19:00:00', 2),            # xs:dateTime
        (u'2002-03-10+13:00', 2),               # xs:date
        (u'2002-06-09-11:00', 2),               # xs:date
        (u'2002-04-08', 2),                     # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:day-of-week-in-month('%s')" % datetime)
        result = DateTime.DayOfWeekInMonth(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_DayOfWeekInMonth)


# date:day-in-week()
def test_DayInWeek(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 6),      # xs:dateTime
        (u'2002-05-09T19:00:00Z', 5),           # xs:dateTime
        (u'2002-11-09T19:00:00', 7),            # xs:dateTime
        (u'2002-03-10+13:00', 1),               # xs:date
        (u'2002-06-09-11:00', 1),               # xs:date
        (u'2002-04-08', 2),                     # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:day-in-week('%s')" % datetime)
        result = DateTime.DayInWeek(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_DayInWeek)


# date:day-name()
def test_DayName(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', u'Friday'), # xs:dateTime
        (u'2002-05-09T19:00:00Z', u'Thursday'), # xs:dateTime
        (u'2002-11-09T19:00:00', u'Saturday'),  # xs:dateTime
        (u'2002-03-10+13:00', u'Sunday'),       # xs:date
        (u'2002-06-09-11:00', u'Sunday'),       # xs:date
        (u'2002-04-08', u'Monday'),             # xs:date
        (u'12:20:00-05:00', u''),               # xs:time
        (u'17:20:00Z', u''),                    # xs:time
        (u'24:00:00', u''),                     # xs:time
        (u'1999-12Z', u''),                     # xs:gYearMonth
        (u'1999-04', u''),                      # xs:gYearMonth
        (u'1999-07:00', u''),                   # xs:gYear
        (u'1999', u''),                         # xs:gYear
        (u'--08-14+14:00', u''),                # xs:gMonthDay
        (u'--09-14', u''),                      # xs:gMonthDay
        (u'--07-11:00', u'') ,                  # xs:gMonth
        (u'--10', u''),                         # xs:gMonth
        (u'---05Z', u''),                       # xs:gDay
        (u'---09', u''),                        # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:day-name('%s')" % datetime)
        result = DateTime.DayName(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_DayName)


# date:day-abbreviation()
def test_DayAbbreviation(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', u'Fri'), # xs:dateTime
        (u'2002-05-09T19:00:00Z', u'Thu'),      # xs:dateTime
        (u'2002-11-09T19:00:00', u'Sat'),       # xs:dateTime
        (u'2002-03-10+13:00', u'Sun'),          # xs:date
        (u'2002-06-09-11:00', u'Sun'),          # xs:date
        (u'2002-04-08', u'Mon'),                # xs:date
        (u'12:20:00-05:00', u''),               # xs:time
        (u'17:20:00Z', u''),                    # xs:time
        (u'24:00:00', u''),                     # xs:time
        (u'1999-12Z', u''),                     # xs:gYearMonth
        (u'1999-04', u''),                      # xs:gYearMonth
        (u'1999-07:00', u''),                   # xs:gYear
        (u'1999', u''),                         # xs:gYear
        (u'--08-14+14:00', u''),                # xs:gMonthDay
        (u'--09-14', u''),                      # xs:gMonthDay
        (u'--07-11:00', u'') ,                  # xs:gMonth
        (u'--10', u''),                         # xs:gMonth
        (u'---05Z', u''),                       # xs:gDay
        (u'---09', u''),                        # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:day-abbreviation('%s')" % datetime)
        result = DateTime.DayAbbreviation(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_DayAbbreviation)


# date:hour-in-day()
def test_HourInDay(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 0),      # xs:dateTime
        (u'2002-05-09T19:00:00Z', 19),          # xs:dateTime
        (u'2002-11-09T19:00:00', 19),           # xs:dateTime
        (u'2002-03-10+13:00', number.nan),      # xs:date
        (u'2002-06-09-11:00', number.nan),      # xs:date
        (u'2002-04-08', number.nan),            # xs:date
        (u'12:20:00-05:00', 12),                # xs:time
        (u'17:20:00Z', 17),                     # xs:time
        (u'24:00:00', 24),                      # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:hour-in-day('%s')" % datetime)
        result = DateTime.HourInDay(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_HourInDay)


# date:minute-in-hour()
def test_MinuteInHour(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 0),      # xs:dateTime
        (u'2002-05-09T19:00:00Z', 0),           # xs:dateTime
        (u'2002-11-09T19:00:00', 0),            # xs:dateTime
        (u'2002-03-10+13:00', number.nan),      # xs:date
        (u'2002-06-09-11:00', number.nan),      # xs:date
        (u'2002-04-08', number.nan),            # xs:date
        (u'12:20:00-05:00', 20),                # xs:time
        (u'17:20:00Z', 20),                     # xs:time
        (u'24:00:00', 0),                       # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:minute-in-hour('%s')" % datetime)
        result = DateTime.MinuteInHour(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_MinuteInHour)


# date:second-in-minute()
def test_SecondInMinute(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 0),      # xs:dateTime
        (u'2002-05-09T19:00:10Z', 10),          # xs:dateTime
        (u'2002-11-09T19:00:20', 20),           # xs:dateTime
        (u'2002-03-10+13:00', number.nan),      # xs:date
        (u'2002-06-09-11:00', number.nan),      # xs:date
        (u'2002-04-08', number.nan),            # xs:date
        (u'12:20:46-05:00', 46),                # xs:time
        (u'17:20:46Z', 46),                     # xs:time
        (u'24:00:00', 0),                       # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        ]
    for datetime, expected in tests:
        tester.startTest("date:second-in-minute('%s')" % datetime)
        result = DateTime.SecondInMinute(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_SecondInMinute)


# date:format-date()
def test_FormatDate(tester):
    datetime = "2001-07-04T12:08:56.235-07:00"
    tests = [
        ("yyyy.MM.dd G 'at' HH:mm:ss", u"2001.07.04 AD at 12:08:56"),
        ("EEE, MMM d, ''yy", u"Wed, Jul 4, '01"),
        ("h:mm a", u"12:08 PM"),
        ("hh 'o''clock' a, zzzz", u"12 o'clock PM, -07:00"),
        ("K:mm a", u"0:08 PM"),
        ("yyyyy.MMMMM.dd GGG hh:mm aaa", u"02001.July.04 AD 12:08 PM"),
        ("EEE, d MMM yyyy HH:mm:ss", u"Wed, 4 Jul 2001 12:08:56"),
        ("yyMMddHHmmssz", u"010704120856-07:00"),
        #("yyyy-MM-dd'T'HH:mm:ss.SSSz", u"2001-07-04T12:08:56.235-07:00"),
        ]
    for pattern, expected in tests:
        tester.startTest('date:format-date(%r, %r)' % (datetime, pattern))
        result = DateTime.FormatDate(None, datetime, pattern)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_FormatDate)


# date:week-in-month()
def test_WeekInMonth(tester):
    tests = [
        (u'2002-05-10T00:00:00+05:00', 2),      # xs:dateTime
        (u'2002-05-09T19:00:00Z', 2),           # xs:dateTime
        (u'2002-11-09T19:00:00', 2),            # xs:dateTime
        (u'2002-03-10+13:00', 2),               # xs:date
        (u'2002-06-09-11:00', 2),               # xs:date
        (u'2002-04-08', 2),                     # xs:date
        (u'12:20:00-05:00', number.nan),        # xs:time
        (u'17:20:00Z', number.nan),             # xs:time
        (u'24:00:00', number.nan),              # xs:time
        (u'1999-12Z', number.nan),              # xs:gYearMonth
        (u'1999-04', number.nan),               # xs:gYearMonth
        (u'1999-07:00', number.nan),            # xs:gYear
        (u'1999', number.nan),                  # xs:gYear
        (u'--08-14+14:00', number.nan),         # xs:gMonthDay
        (u'--09-14', number.nan),               # xs:gMonthDay
        (u'--07-11:00', number.nan),            # xs:gMonth
        (u'--10', number.nan),                  # xs:gMonth
        (u'---05Z', number.nan),                # xs:gDay
        (u'---09', number.nan),                 # xs:gDay
        # test case some edge cases
        (u'1969-12-30', 5),
        (u'1971-01-01', 1),
        (u'1979-12-31', 6),
        (u'1984-01-01', 1),
        (u'1991-12-30', 6),
        (u'1999-01-03', 1),
        (u'2012-12-31', 6),
        (u'2017-01-01', 1),
        (u'2029-01-01', 1),
        ]
    for datetime, expected in tests:
        tester.startTest("date:month-in-month('%s')" % datetime)
        result = DateTime.WeekInMonth(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_WeekInMonth)


# date:seconds()
def test_Seconds(tester):
    tests = [
        # durations
        ('P0DT0H0M0S', 0),
        ('P0DT0H0M59S', 59),
        ('P0DT0H1M0S', 60),
        ('P0DT0H59M59S', 3599),
        ('P0DT1H0M0S', 3600),
        ('P0DT23H59M59S', 86399),
        ('P1DT0H0M0S', 86400),
        # duration years and months are not allowed
        ('P60DT0H0M0S', 86400*60),
        ('P2M', number.nan),
        ('P400DT0H0M0S', 86400*400),
        ('P1Y1M4D', number.nan),
        # dateTime (difference from 1970-01-01T00:00:00Z
        ('1970-01-01T00:00:00Z', 0),
        ('1970-01-01T00:00:59Z', 59),
        ('1970-01-01T00:01:00Z', 60),
        ('1970-01-01T00:59:59Z', 3599),
        ('1970-01-01T01:00:00Z', 3600),
        ('1970-01-01T23:59:59Z', 86399),
        ('1970-01-02Z', 86400),
        ('1970-03-02Z', 86400*60),
        ('1971-02-05Z', 86400*400),
        ]
    for datetime, expected in tests:
        tester.startTest('date:seconds(%r)' % (datetime))
        result = DateTime.Seconds(None, datetime)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Seconds)


# date:difference()
def test_Difference(tester):
    tests = [
        ('1969-01-01T00:00:00Z', '1970-01-01T00:00:00Z', 'P365D'),
        ('1969-01-01T00:00:00Z', '1970-01-01T00:00:59Z', 'P365DT59S'),
        ('1969-01-01T00:00:00Z', '1970-01-01T00:01:00Z', 'P365DT1M'),
        ('1969-01-01T00:00:00Z', '1970-01-01T00:59:59Z', 'P365DT59M59S'),
        ('1969-01-01T00:00:00Z', '1970-01-01T01:00:00Z', 'P365DT1H'),
        ('1969-01-01T00:00:00Z', '1970-01-01T23:59:59Z', 'P365DT23H59M59S'),
        ('1969-01-01T00:00:00Z', '1970-01-02Z', 'P366D'),
        ('1969-01-01T00:00:00Z', '1970-03-02Z', 'P425D'),
        ('1969-01-01T00:00:00Z', '1971-02-05Z', 'P765D'),
        ('1969-01-01T00:00:00Z', '1972-02Z', 'P3Y1M'),
        ('1969-01-01T00:00:00Z', '1973Z', 'P4Y'),

        ('1970-01-01T00:00:00Z', '1970-01-01T00:00:00Z', 'PT0S'),
        ('1970-01-01T00:00:00Z', '1970-01-01T00:00:59Z', 'PT59S'),
        ('1970-01-01T00:00:00Z', '1970-01-01T00:01:00Z', 'PT1M'),
        ('1970-01-01T00:00:00Z', '1970-01-01T00:59:59Z', 'PT59M59S'),
        ('1970-01-01T00:00:00Z', '1970-01-01T01:00:00Z', 'PT1H'),
        ('1970-01-01T00:00:00Z', '1970-01-01T23:59:59Z', 'PT23H59M59S'),
        ('1970-01-01T00:00:00Z', '1970-01-02Z', 'P1D'),
        ('1970-01-01T00:00:00Z', '1970-03-02Z', 'P60D'),
        ('1970-01-01T00:00:00Z', '1971-02-05Z', 'P400D'),
        ('1970-01-01T00:00:00Z', '1972-02Z', 'P2Y1M'),
        ('1970-01-01T00:00:00Z', '1973Z', 'P3Y'),

        ('1971-01-01T00:00:00Z', '1970-01-01T00:00:00Z', '-P365D'),
        ('1971-01-01T00:00:00Z', '1970-01-01T00:00:59Z', '-P364DT23H59M1S'),
        ('1971-01-01T00:00:00Z', '1970-01-01T00:01:00Z', '-P364DT23H59M'),
        ('1971-01-01T00:00:00Z', '1970-01-01T00:59:59Z', '-P364DT23H1S'),
        ('1971-01-01T00:00:00Z', '1970-01-01T01:00:00Z', '-P364DT23H'),
        ('1971-01-01T00:00:00Z', '1970-01-01T23:59:59Z', '-P364DT1S'),
        ('1971-01-01T00:00:00Z', '1970-01-02Z', '-P364D'),
        ('1971-01-01T00:00:00Z', '1970-03-02Z', '-P305D'),
        ('1971-01-01T00:00:00Z', '1971-02-05Z', 'P35D'),
        ('1971-01-01T00:00:00Z', '1972-02Z', 'P1Y1M'),
        ('1971-01-01T00:00:00Z', '1973Z', 'P2Y'),
        ]
    for start, end, expected in tests:
        tester.startTest('date:difference(%r, %r)' % (start, end))
        result = DateTime.Difference(None, start, end)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Difference)


# date:add()
def test_Add(tester):
    tests = [
        ('1969-01-01T00:00:00Z', 'P365D', '1970-01-01T00:00:00Z'),
        ('1969-01-01T00:00:00Z', 'P365DT59S', '1970-01-01T00:00:59Z'),
        ('1969-01-01T00:00:00Z', 'P365DT1M', '1970-01-01T00:01:00Z'),
        ('1969-01-01T00:00:00Z', 'P365DT59M59S', '1970-01-01T00:59:59Z'),
        ('1969-01-01T00:00:00Z', 'P365DT1H', '1970-01-01T01:00:00Z'),
        ('1969-01-01T00:00:00Z', 'P365DT23H59M59S', '1970-01-01T23:59:59Z'),
        ('1969-01-01Z', 'P366D', '1970-01-02Z'),
        ('1969-01-01Z', 'P425D', '1970-03-02Z'),
        ('1969-01-01Z', 'P765D', '1971-02-05Z'),
        ('1969-01Z', 'P3Y1M', '1972-02Z'),
        ('1969Z', 'P4Y', '1973Z'),

        ('1970-01-01T00:00:00Z', 'PT0S', '1970-01-01T00:00:00Z'),
        ('1970-01-01T00:00:00Z', 'PT59S', '1970-01-01T00:00:59Z'),
        ('1970-01-01T00:00:00Z', 'PT1M', '1970-01-01T00:01:00Z'),
        ('1970-01-01T00:00:00Z', 'PT59M59S', '1970-01-01T00:59:59Z'),
        ('1970-01-01T00:00:00Z', 'PT1H', '1970-01-01T01:00:00Z'),
        ('1970-01-01T00:00:00Z', 'PT23H59M59S', '1970-01-01T23:59:59Z'),
        ('1970-01-01Z', 'P1D', '1970-01-02Z'),
        ('1970-01-01Z', 'P60D', '1970-03-02Z'),
        ('1970-01-01Z', 'P400D', '1971-02-05Z'),
        ('1970-01Z', 'P2Y1M', '1972-02Z'),
        ('1970Z', 'P3Y', '1973Z'),

        ('1971-01-01T00:00:00Z', '-P365D', '1970-01-01T00:00:00Z'),
        ('1971-01-01T00:00:00Z', '-P364DT23H59M1S', '1970-01-01T00:00:59Z'),
        ('1971-01-01T00:00:00Z', '-P364DT23H59M', '1970-01-01T00:01:00Z'),
        ('1971-01-01T00:00:00Z', '-P364DT23H1S', '1970-01-01T00:59:59Z'),
        ('1971-01-01T00:00:00Z', '-P364DT23H', '1970-01-01T01:00:00Z'),
        ('1971-01-01T00:00:00Z', '-P364DT1S', '1970-01-01T23:59:59Z'),
        ('1971-01-01Z', '-P364D', '1970-01-02Z'),
        ('1971-01-01Z', '-P305D', '1970-03-02Z'),
        ('1971-01-01Z', 'P35D', '1971-02-05Z'),
        ('1971-01Z', 'P1Y1M', '1972-02Z'),
        ('1971Z', 'P2Y', '1973Z'),

        ('2000-01', '-P3M', '1999-10'),
        ('2000-01-12', 'PT33H', '2000-01-13'),
        ('2000-01-12T12:13:14Z', 'P1Y3M5DT7H10M3.3S', '2001-04-17T19:23:17.3Z')
        ]


    for datetime, duration, expected in tests:
        tester.startTest('date:add(%r, %r)' % (datetime, duration))
        result = DateTime.Add(None, datetime, duration)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Add)


# date:add-duration()
def test_AddDuration(tester):
    tests = [
        ('PT3S', 'PT7S', 'PT10S'),
        ('PT59S', 'PT1S', 'PT1M'),
        ('PT59M59S', 'PT1S', 'PT1H'),
        ('PT23H59M59S', 'PT1S', 'P1D'),
        # 30+D != 1M
        ('P33D', 'P1Y1M', 'P1Y1M33D'),
        ('P1M', '-P30D', '')
        ]
    for duration1, duration2, expected in tests:
        tester.startTest('date:add-duration(%r, %r)' % (duration1, duration2))
        result = DateTime.AddDuration(None, duration1, duration2)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_AddDuration)


# date:sum()
def test_Sum(tester):
    tests = [
        (['PT3S', 'PT7S'], 'PT10S'),
        (['PT59S', 'PT1S'], 'PT1M'),
        (['PT59M59S', 'PT1S'], 'PT1H'),
        (['PT23H59M59S', 'PT1S'], 'P1D'),
        # 30+D != 1M
        (['P33D', 'P1Y1M'], 'P1Y1M33D'),
        (['P1M', '-P30D'], ''),
        (['P1M', '-P30D', 'P30D'], 'P1M'),
        ]
    for durations, expected in tests:
        tester.startTest('date:sum(%r)' % (durations))
        result = DateTime.Sum(None, durations)
        tester.compare(expected, result)
        tester.testDone()
    return
TESTS.append(test_Sum)


# date:duration()
def test_Duration(tester):
    tests = [
        (0, u'PT0S'),
        (59, u'PT59S'),
        (60, u'PT1M'),
        (3599, u'PT59M59S'),
        (3600, u'PT1H'),
        (86399, u'PT23H59M59S'),
        (86400, u'P1D'),
        # Make sure that only days are returned, no months or years
        (86400*60, u'P60D'),
        (86400*400, u'P400D'),
        ]
    for seconds, expected in tests:
        tester.startTest('date:duration(%0.12g)' % (seconds))
        result = DateTime.Duration(None, seconds)
        tester.compare(expected, result)
        tester.testDone()
        # Test negatives as well (if not epoch, as it cannot be negative)
        if seconds:
            seconds *= -1
            expected = '-' + expected
            tester.startTest('date:duration(%0.12g)' % (seconds))
            result = DateTime.Duration(None, seconds)
            tester.compare(expected, result)
            tester.testDone()
    return
TESTS.append(test_Duration)


def Test(tester):
    tester.startGroup('Dates and Times')
    for test in TESTS:
        test(tester)
    tester.groupDone()
    return