import py
import ctime

import os

def setup_module(mod):
    mod.t = ctime.time()
    mod.tup = (1, 2, 3, 4, 5, 6, 7, 8, 9)
    mod.st_time = ctime.struct_time(mod.tup)

def test_time():
    assert t != None
    assert t != 0.0

def test_attributes():
    assert isinstance(ctime.accept2dyear, int)
    assert isinstance(ctime.altzone, int)
    assert isinstance(ctime.daylight, int)
    assert isinstance(ctime.timezone, int)
    assert isinstance(ctime.tzname, tuple)

def test_sleep():
    py.test.raises(TypeError, ctime.sleep, "foo")
    ctime.sleep(1.2345)

def test_clock():
    assert ctime.clock() != None
    assert ctime.clock() != 0.0

def test_accept2dyear():
    assert ctime.accept2dyear == 1

def test_ctime():
    py.test.raises(TypeError, ctime.ctime, "foo")
    assert ctime.ctime() != None
    assert ctime.ctime() != ""
    assert ctime.ctime(None) != None
    assert ctime.ctime(None) != ""

def test_gmtime():
    py.test.raises(TypeError, ctime.gmtime, "foo")
    assert ctime.gmtime() != None
    assert ctime.gmtime() != ()
    assert ctime.gmtime(None) != None
    assert ctime.gmtime(None) != ()
    t0 = ctime.mktime(ctime.gmtime())
    t1 = ctime.mktime(ctime.gmtime(None))
    assert 0 <= (t1 - t0) < 0.2
    assert ctime.gmtime(t) == ctime.gmtime(t)

def test_localtime():
    py.test.raises(TypeError, ctime.localtime, "foo")
    assert ctime.localtime() != None
    assert ctime.localtime() != ()
    assert ctime.localtime(None) != None
    assert ctime.localtime(None) != ()
    t0 = ctime.mktime(ctime.gmtime())
    t1 = ctime.mktime(ctime.gmtime(None))
    assert 0 <= (t1 - t0) < 0.2
    assert ctime.localtime(t) == ctime.localtime(t)

def test_mktime():
    py.test.raises(TypeError, ctime.mktime, "foo")
    py.test.raises(TypeError, ctime.mktime, None)
    py.test.raises(TypeError, ctime.mktime, (1, 2))

    arg = ctime.localtime(t)

    assert ctime.mktime(arg) != None
    assert ctime.mktime(arg) != 0.0

    ctime.accept2dyear == 0
    arg = list(arg)
    arg[0] = 1899
    arg = tuple(arg)
    py.test.raises(ValueError, ctime.mktime, arg)
    ctime.accept2dyear == 1

    arg = list(arg)
    arg[0] = 67
    arg = tuple(arg)
    py.test.raises(OverflowError, ctime.mktime, arg)

    arg = list(arg)
    arg[0] = 100
    arg = tuple(arg)
    py.test.raises(ValueError, ctime.mktime, arg)

    assert long(ctime.mktime(ctime.localtime(t))) == long(t)
    assert long(ctime.mktime(ctime.gmtime(t))) != long(t)
    lt = ctime.localtime()
    assert ctime.mktime(tuple(lt)) == ctime.mktime(lt)

def test_asctime():
    py.test.raises(TypeError, ctime.asctime, "foo")
    py.test.raises(TypeError, ctime.asctime, None)
    py.test.raises(TypeError, ctime.asctime, (1, 2))
    assert ctime.asctime() != None
    assert ctime.asctime() != ""
    assert ctime.ctime(t) == ctime.asctime(ctime.localtime(t))
    assert ctime.ctime(t) != ctime.asctime(ctime.gmtime(t))
    lt = ctime.localtime()
    assert ctime.asctime(tuple(lt)) == ctime.asctime(lt)

def test_struct_time():
    py.test.raises(TypeError, ctime.struct_time)
    py.test.raises(TypeError, ctime.struct_time, "foo")
    py.test.raises(TypeError, ctime.struct_time, (1, 2, 3))
    assert str(st_time) == str(tup)

def test_tzset():
    if not hasattr(ctime, "tzset"):
        py.test.skip("available only under Unix")

    # epoch time of midnight Dec 25th 2002. Never DST in northern
    # hemisphere.
    xmas2002 = 1040774400.0

    # these formats are correct for 2002, and possibly future years
    # this format is the 'standard' as documented at:
    # http://www.opengroup.org/onlinepubs/007904975/basedefs/xbd_chap08.html
    # They are also documented in the tzset(3) man page on most Unix
    # systems.
    eastern = 'EST+05EDT,M4.1.0,M10.5.0'
    victoria = 'AEST-10AEDT-11,M10.5.0,M3.5.0'
    utc = 'UTC+0'

    org_TZ = os.environ.get('TZ', None)
    try:
        # Make sure we can switch to UTC time and results are correct
        # Note that unknown timezones default to UTC.
        # Note that altzone is undefined in UTC, as there is no DST
        os.environ['TZ'] = eastern
        ctime.tzset()
        os.environ['TZ'] = utc
        ctime.tzset()
        assert ctime.gmtime(xmas2002) == ctime.localtime(xmas2002)
        assert ctime.daylight == 0
        assert ctime.timezone == 0
        assert ctime.localtime(xmas2002).tm_isdst == 0

        # make sure we can switch to US/Eastern
        os.environ['TZ'] = eastern
        ctime.tzset()
        assert ctime.gmtime(xmas2002) != ctime.localtime(xmas2002)
        assert ctime.tzname == ('EST', 'EDT')
        assert len(ctime.tzname) == 2
        assert ctime.daylight == 1
        assert ctime.timezone == 18000
        assert ctime.altzone == 14400
        assert ctime.localtime(xmas2002).tm_isdst == 0

        # now go to the southern hemisphere.
        os.environ['TZ'] = victoria
        ctime.tzset()
        assert ctime.gmtime(xmas2002) != ctime.localtime(xmas2002)
        assert ctime.tzname[0] == 'AEST'
        assert ctime.tzname[1] == 'AEDT'
        assert len(ctime.tzname) == 2
        assert ctime.daylight == 1
        assert ctime.timezone == -36000
        assert ctime.altzone == -39600
        assert ctime.localtime(xmas2002).tm_isdst == 1
    finally:
        # repair TZ environment variable in case any other tests
        # rely on it.
        if org_TZ is not None:
            os.environ['TZ'] = org_TZ
        elif os.environ.has_key('TZ'):
            del os.environ['TZ']
        ctime.tzset()

def test_strftime():
    tt = ctime.gmtime(t)
    for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',
                      'j', 'm', 'M', 'p', 'S',
                      'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
        format = ' %' + directive
        assert ctime.strftime(format, tt) != None
        assert ctime.strftime(format, tt) != ""

def test_strftime_bounds_checking():
    # make sure that strftime() checks the bounds of the various parts
    # of the time tuple.

    raises = py.test.raises

    # check year
    raises(ValueError, ctime.strftime, '', (1899, 1, 1, 0, 0, 0, 0, 1, -1))
    if ctime.accept2dyear:
        raises(ValueError, ctime.strftime, '', (-1, 1, 1, 0, 0, 0, 0, 1, -1))
        raises(ValueError, ctime.strftime, '', (100, 1, 1, 0, 0, 0, 0, 1, -1))
    # check month
    raises(ValueError, ctime.strftime, '', (1900, 0, 1, 0, 0, 0, 0, 1, -1))
    raises(ValueError, ctime.strftime, '', (1900, 13, 1, 0, 0, 0, 0, 1, -1))
    # check day of month
    raises(ValueError, ctime.strftime, '', (1900, 1, 0, 0, 0, 0, 0, 1, -1))
    raises(ValueError, ctime.strftime, '', (1900, 1, 32, 0, 0, 0, 0, 1, -1))
    # check hour
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, -1, 0, 0, 0, 1, -1))
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 24, 0, 0, 0, 1, -1))
    # check minute
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, -1, 0, 0, 1, -1))
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 60, 0, 0, 1, -1))
    # check second
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, -1, 0, 1, -1))
    # C99 only requires allowing for one leap second, but Python's docs say
    # allow two leap seconds (0..61)
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, 62, 0, 1, -1))
    # no check for upper-bound day of week;
    #  value forced into range by a "% 7" calculation.
    # start check at -2 since gettmarg() increments value before taking
    #  modulo.
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, 0, -2, 1, -1))
    # check day of the year
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, 0, 0, 0, -1))
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, 0, 0, 367, -1))
    # check daylight savings flag
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, 0, 0, 1, -2))
    raises(ValueError, ctime.strftime, '', (1900, 1, 1, 0, 0, 0, 0, 1, 2))

def test_strptime():
    tt = ctime.gmtime(t)
    for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',
                      'j', 'm', 'M', 'p', 'S',
                      'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
        format = ' %' + directive
        try:
            assert ctime.strptime(ctime.strftime(format, tt), format) != None
        except ValueError:
            raise ValueError, "conversion specifier: %r failed.' % format"