#!/usr/bin/env python3
"""Tests for the date and time interfaces."""

import unittest

from dfdatetime import definitions
from dfdatetime import interface


class EmptyDateTimeValues(interface.DateTimeValues):
    """Empty date time values for testing."""

    # pylint: disable=abstract-method,redundant-returns-doc

    def _GetNormalizedTimestamp(self):
        """Retrieves the normalized timestamp.

        Returns:
          float: normalized timestamp, which is None for testing purposes.
        """
        return None


class TestDateTimeValues(interface.DateTimeValues):
    """Date time values for testing."""

    # pylint: disable=abstract-method

    def _GetNormalizedTimestamp(self):
        """Retrieves the normalized timestamp.

        Returns:
          float: normalized timestamp, which is 0.0 for testing purposes.
        """
        return 0.0


class DateTimeEpochTest(unittest.TestCase):
    """Tests for the date and time epoch interface."""

    def testInitialize(self):
        """Tests the __init__ function."""
        date_time_epoch = interface.DateTimeEpoch(1970, 1, 1)
        self.assertIsNotNone(date_time_epoch)


class DateTimeValuesTest(unittest.TestCase):
    """Tests for the date and time values interface."""

    # pylint: disable=protected-access

    def testIsDelta(self):
        """Tests the is_delta property."""
        date_time_values = interface.DateTimeValues(is_delta=True)
        self.assertTrue(date_time_values.is_delta)

    def testPrecision(self):
        """Tests the precision property."""
        date_time_values = interface.DateTimeValues(
            precision=definitions.PRECISION_1_MILLISECOND
        )
        self.assertEqual(date_time_values.precision, "1ms")

    def testTimeZoneOffset(self):
        """Tests the time_zone_offset property."""
        date_time_values = interface.DateTimeValues(time_zone_offset=60)
        self.assertEqual(date_time_values.time_zone_offset, 60)

    def testComparison(self):
        """Tests the comparison functions."""
        date_time_values1 = EmptyDateTimeValues()

        date_time_values2 = EmptyDateTimeValues()

        self.assertTrue(date_time_values1 == date_time_values2)
        self.assertTrue(date_time_values1 >= date_time_values2)
        self.assertFalse(date_time_values1 > date_time_values2)
        self.assertTrue(date_time_values1 <= date_time_values2)
        self.assertFalse(date_time_values1 < date_time_values2)
        self.assertFalse(date_time_values1 != date_time_values2)

        date_time_values1 = EmptyDateTimeValues()

        date_time_values2 = TestDateTimeValues()

        self.assertFalse(date_time_values1 == date_time_values2)
        self.assertFalse(date_time_values1 >= date_time_values2)
        self.assertFalse(date_time_values1 > date_time_values2)
        self.assertTrue(date_time_values1 <= date_time_values2)
        self.assertTrue(date_time_values1 < date_time_values2)
        self.assertTrue(date_time_values1 != date_time_values2)

        date_time_values1 = TestDateTimeValues()

        date_time_values2 = EmptyDateTimeValues()

        self.assertFalse(date_time_values1 == date_time_values2)
        self.assertTrue(date_time_values1 >= date_time_values2)
        self.assertTrue(date_time_values1 > date_time_values2)
        self.assertFalse(date_time_values1 <= date_time_values2)
        self.assertFalse(date_time_values1 < date_time_values2)
        self.assertTrue(date_time_values1 != date_time_values2)

        date_time_values1 = TestDateTimeValues()

        date_time_values2 = TestDateTimeValues()

        self.assertTrue(date_time_values1 == date_time_values2)
        self.assertTrue(date_time_values1 >= date_time_values2)
        self.assertFalse(date_time_values1 > date_time_values2)
        self.assertTrue(date_time_values1 <= date_time_values2)
        self.assertFalse(date_time_values1 < date_time_values2)
        self.assertFalse(date_time_values1 != date_time_values2)

        self.assertFalse(date_time_values1 == 0.0)

        with self.assertRaises(ValueError):
            date_time_values1 >= 0.0  # pylint: disable=pointless-statement

        with self.assertRaises(ValueError):
            date_time_values1 > 0.0  # pylint: disable=pointless-statement

        with self.assertRaises(ValueError):
            date_time_values1 <= 0.0  # pylint: disable=pointless-statement

        with self.assertRaises(ValueError):
            date_time_values1 < 0.0  # pylint: disable=pointless-statement

        self.assertTrue(date_time_values1 != 0.0)

    def testCopyDateFromString(self):
        """Tests the _CopyDateFromString function."""
        date_time_values = interface.DateTimeValues()

        expected_date_tuple = (2010, 1, 1)
        date_tuple = date_time_values._CopyDateFromString("2010-01-01")
        self.assertEqual(date_tuple, expected_date_tuple)

        expected_date_tuple = (2010, 8, 1)
        date_tuple = date_time_values._CopyDateFromString("2010-08-01")
        self.assertEqual(date_tuple, expected_date_tuple)

        expected_date_tuple = (2010, 8, 12)
        date_tuple = date_time_values._CopyDateFromString("2010-08-12")
        self.assertEqual(date_tuple, expected_date_tuple)

        expected_date_tuple = (2010, 8, 31)
        date_tuple = date_time_values._CopyDateFromString("2010-08-31")
        self.assertEqual(date_tuple, expected_date_tuple)

        expected_date_tuple = (2010, 12, 31)
        date_tuple = date_time_values._CopyDateFromString("2010-12-31")
        self.assertEqual(date_tuple, expected_date_tuple)

        expected_date_tuple = (1601, 1, 2)
        date_tuple = date_time_values._CopyDateFromString("1601-01-02")
        self.assertEqual(date_tuple, expected_date_tuple)

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("195a-01-02")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("10000-01-02")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("2010-09-00")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("2010-09-31")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("1601-01-32")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("1601-01-b2")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("1601-13-02")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("1601-a1-02")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("2010-02-29")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateFromString("2010-04-31")

    def testCopyDateTimeFromString(self):
        """Tests the _CopyDateTimeFromString function."""
        date_time_values = interface.DateTimeValues()

        expected_date_dict = {"year": 2010, "month": 8, "day_of_month": 12}
        date_dict = date_time_values._CopyDateTimeFromString("2010-08-12")
        self.assertEqual(date_dict, expected_date_dict)

        expected_date_dict = {
            "year": 2010,
            "month": 8,
            "day_of_month": 12,
            "hours": 21,
            "minutes": 6,
            "seconds": 31,
        }
        date_dict = date_time_values._CopyDateTimeFromString("2010-08-12 21:06:31")
        self.assertEqual(date_dict, expected_date_dict)

        expected_date_dict = {
            "year": 2010,
            "month": 8,
            "day_of_month": 12,
            "hours": 21,
            "minutes": 6,
            "seconds": 31,
            "nanoseconds": 546875000,
        }
        date_dict = date_time_values._CopyDateTimeFromString(
            "2010-08-12 21:06:31.546875"
        )
        self.assertEqual(date_dict, expected_date_dict)

        expected_date_dict = {
            "year": 2010,
            "month": 8,
            "day_of_month": 12,
            "hours": 21,
            "minutes": 6,
            "seconds": 31,
            "nanoseconds": 546875000,
            "time_zone_offset": -60,
        }
        date_dict = date_time_values._CopyDateTimeFromString(
            "2010-08-12 21:06:31.546875-01:00"
        )
        self.assertEqual(date_dict, expected_date_dict)

        expected_date_dict = {
            "year": 2010,
            "month": 8,
            "day_of_month": 12,
            "hours": 21,
            "minutes": 6,
            "seconds": 31,
            "nanoseconds": 546875000,
            "time_zone_offset": 60,
        }
        date_dict = date_time_values._CopyDateTimeFromString(
            "2010-08-12 21:06:31.546875+01:00"
        )
        self.assertEqual(date_dict, expected_date_dict)

        expected_date_dict = {
            "year": 2010,
            "month": 8,
            "day_of_month": 12,
            "hours": 21,
            "minutes": 6,
            "seconds": 31,
            "nanoseconds": 546875333,
        }
        date_dict = date_time_values._CopyDateTimeFromString(
            "2010-08-12 21:06:31.546875333"
        )
        self.assertEqual(date_dict, expected_date_dict)

        expected_date_dict = {
            "year": 2010,
            "month": 8,
            "day_of_month": 12,
            "hours": 21,
            "minutes": 6,
            "seconds": 31,
            "nanoseconds": 546875333,
            "time_zone_offset": 60,
        }
        date_dict = date_time_values._CopyDateTimeFromString(
            "2010-08-12 21:06:31.546875333+01:00"
        )
        self.assertEqual(date_dict, expected_date_dict)

        with self.assertRaises(ValueError):
            date_time_values._CopyDateTimeFromString("")

        with self.assertRaises(ValueError):
            date_time_values._CopyDateTimeFromString("2010-08-12T21:06:31.546875+01:00")

    def testCopyTimeFromString(self):
        """Tests the _CopyTimeFromString function."""
        date_time_values = interface.DateTimeValues()

        expected_time_tuple = (8, 4, 32, None, None)
        time_tuple = date_time_values._CopyTimeFromString("08:04:32")
        self.assertEqual(time_tuple, expected_time_tuple)

        expected_time_tuple = (20, 23, 56, None, None)
        time_tuple = date_time_values._CopyTimeFromString("20:23:56")
        self.assertEqual(time_tuple, expected_time_tuple)

        expected_time_tuple = (20, 23, 56, None, 330)
        time_tuple = date_time_values._CopyTimeFromString("20:23:56+05:30")
        self.assertEqual(time_tuple, expected_time_tuple)

        expected_time_tuple = (20, 23, 56, 327000000, None)
        time_tuple = date_time_values._CopyTimeFromString("20:23:56.327")
        self.assertEqual(time_tuple, expected_time_tuple)

        expected_time_tuple = (20, 23, 56, 327000000, 60)
        time_tuple = date_time_values._CopyTimeFromString("20:23:56.327+01:00")
        self.assertEqual(time_tuple, expected_time_tuple)

        expected_time_tuple = (20, 23, 56, 327124000, None)
        time_tuple = date_time_values._CopyTimeFromString("20:23:56.327124")
        self.assertEqual(time_tuple, expected_time_tuple)

        expected_time_tuple = (20, 23, 56, 327124000, -300)
        time_tuple = date_time_values._CopyTimeFromString("20:23:56.327124-05:00")
        self.assertEqual(time_tuple, expected_time_tuple)

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("14")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("14:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("24:00:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12b00:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00b00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("1s:00:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("00:60:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("00:e0:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("00:00:60")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("00:00:w0")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00.00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00.0000")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00.00w")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00+01b00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00+0w:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00+20:00")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00+01:0w")

        with self.assertRaises(ValueError):
            date_time_values._CopyTimeFromString("12:00:00+01:60")

    def testGetDateValues(self):
        """Tests the _GetDateValues function."""
        date_time_values = interface.DateTimeValues()

        year, month, day_of_month = date_time_values._GetDateValues(0, 2000, 1, 1)
        self.assertEqual(year, 2000)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 1)

        year, month, day_of_month = date_time_values._GetDateValues(10, 2000, 1, 1)
        self.assertEqual(year, 2000)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 11)

        year, month, day_of_month = date_time_values._GetDateValues(100, 2000, 1, 1)
        self.assertEqual(year, 2000)
        self.assertEqual(month, 4)
        self.assertEqual(day_of_month, 10)

        year, month, day_of_month = date_time_values._GetDateValues(100, 1999, 1, 1)
        self.assertEqual(year, 1999)
        self.assertEqual(month, 4)
        self.assertEqual(day_of_month, 11)

        year, month, day_of_month = date_time_values._GetDateValues(0, 1999, 12, 30)
        self.assertEqual(year, 1999)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 30)

        year, month, day_of_month = date_time_values._GetDateValues(5, 1999, 12, 30)
        self.assertEqual(year, 2000)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 4)

        year, month, day_of_month = date_time_values._GetDateValues(-10, 2000, 1, 1)
        self.assertEqual(year, 1999)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 22)

        year, month, day_of_month = date_time_values._GetDateValues(-100, 2000, 1, 1)
        self.assertEqual(year, 1999)
        self.assertEqual(month, 9)
        self.assertEqual(day_of_month, 23)

        year, month, day_of_month = date_time_values._GetDateValues(-10, 2000, 1, 9)
        self.assertEqual(year, 1999)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 30)

        with self.assertRaises(ValueError):
            date_time_values._GetDateValues(10, -1, 1, 1)

        with self.assertRaises(ValueError):
            date_time_values._GetDateValues(10, 2000, 0, 1)

        with self.assertRaises(ValueError):
            date_time_values._GetDateValues(10, 2000, 13, 1)

        with self.assertRaises(ValueError):
            date_time_values._GetDateValues(10, 2000, 1, 0)

        with self.assertRaises(ValueError):
            date_time_values._GetDateValues(10, 2000, 1, 32)

        year, month, day_of_month = date_time_values._GetDateValues(0, 1899, 12, 30)
        self.assertEqual(year, 1899)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 30)

        year, month, day_of_month = date_time_values._GetDateValues(25569, 1899, 12, 30)
        self.assertEqual(year, 1970)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 1)

        year, month, day_of_month = date_time_values._GetDateValues(36526, 1899, 12, 30)
        self.assertEqual(year, 2000)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 1)

        year, month, day_of_month = date_time_values._GetDateValues(41275, 1899, 12, 30)
        self.assertEqual(year, 2013)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 1)

        year, month, day_of_month = date_time_values._GetDateValues(41443, 1899, 12, 30)
        self.assertEqual(year, 2013)
        self.assertEqual(month, 6)
        self.assertEqual(day_of_month, 18)

        year, month, day_of_month = date_time_values._GetDateValues(
            -25569, 1899, 12, 30
        )
        self.assertEqual(year, 1829)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 28)

        year, month, day_of_month = date_time_values._GetDateValues(0, 1970, 1, 1)
        self.assertEqual(year, 1970)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 1)

        year, month, day_of_month = date_time_values._GetDateValues(-1, 1970, 1, 1)
        self.assertEqual(year, 1969)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 31)

        year, month, day_of_month = date_time_values._GetDateValues(364, 1970, 1, 1)
        self.assertEqual(year, 1970)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 31)

        year, month, day_of_month = date_time_values._GetDateValues(1460, 1970, 1, 1)
        self.assertEqual(year, 1973)
        self.assertEqual(month, 12)
        self.assertEqual(day_of_month, 31)

    def testGetDateValuesWithEpoch(self):
        """Tests the _GetDateValuesWithEpoch function."""
        date_time_epoch = interface.DateTimeEpoch(2000, 1, 1)
        date_time_values = interface.DateTimeValues()

        year, month, day_of_month = date_time_values._GetDateValuesWithEpoch(
            0, date_time_epoch
        )
        self.assertEqual(year, 2000)
        self.assertEqual(month, 1)
        self.assertEqual(day_of_month, 1)

        with self.assertRaises(ValueError):
            date_time_values._GetDateValuesWithEpoch(-1000000000, date_time_epoch)

    def testGetDayOfYear(self):
        """Tests the _GetDayOfYear function."""
        date_time_values = interface.DateTimeValues()

        day_of_year = date_time_values._GetDayOfYear(1999, 1, 1)
        self.assertEqual(day_of_year, 1)

        day_of_year = date_time_values._GetDayOfYear(1999, 4, 21)
        self.assertEqual(day_of_year, 111)

        day_of_year = date_time_values._GetDayOfYear(1999, 12, 31)
        self.assertEqual(day_of_year, 365)

        day_of_year = date_time_values._GetDayOfYear(2000, 1, 1)
        self.assertEqual(day_of_year, 1)

        day_of_year = date_time_values._GetDayOfYear(2000, 4, 21)
        self.assertEqual(day_of_year, 112)

        day_of_year = date_time_values._GetDayOfYear(2000, 12, 31)
        self.assertEqual(day_of_year, 366)

        with self.assertRaises(ValueError):
            date_time_values._GetDayOfYear(1999, 0, 1)

        with self.assertRaises(ValueError):
            date_time_values._GetDayOfYear(1999, 13, 1)

        with self.assertRaises(ValueError):
            date_time_values._GetDayOfYear(1999, 1, 0)

        with self.assertRaises(ValueError):
            date_time_values._GetDayOfYear(1999, 1, 32)

    def testGetDaysPerMonth(self):
        """Tests the _GetDaysPerMonth function."""
        date_time_values = interface.DateTimeValues()

        expected_days_per_month = list(definitions.DAYS_PER_MONTH)

        days_per_month = []
        for month in range(1, 13):
            days_per_month.append(date_time_values._GetDaysPerMonth(1999, month))

        self.assertEqual(days_per_month, expected_days_per_month)

        expected_days_per_month[1] += 1

        days_per_month = []
        for month in range(1, 13):
            days_per_month.append(date_time_values._GetDaysPerMonth(2000, month))

        self.assertEqual(days_per_month, expected_days_per_month)

        with self.assertRaises(ValueError):
            date_time_values._GetDaysPerMonth(1999, 0)

        with self.assertRaises(ValueError):
            date_time_values._GetDaysPerMonth(1999, 13)

    def testGetNumberOfDaysInCentury(self):
        """Tests the _GetNumberOfDaysInCentury function."""
        date_time_values = interface.DateTimeValues()

        self.assertEqual(date_time_values._GetNumberOfDaysInCentury(1700), 36524)
        self.assertEqual(date_time_values._GetNumberOfDaysInCentury(2000), 36525)
        self.assertEqual(date_time_values._GetNumberOfDaysInCentury(10000), 36525)
        self.assertEqual(date_time_values._GetNumberOfDaysInCentury(10100), 36524)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfDaysInCentury(-1)

    def testGetNumberOfDaysInYear(self):
        """Tests the _GetNumberOfDaysInYear function."""
        date_time_values = interface.DateTimeValues()

        self.assertEqual(date_time_values._GetNumberOfDaysInYear(1999), 365)
        self.assertEqual(date_time_values._GetNumberOfDaysInYear(2000), 366)
        self.assertEqual(date_time_values._GetNumberOfDaysInYear(1996), 366)
        self.assertEqual(date_time_values._GetNumberOfDaysInYear(10000), 366)
        self.assertEqual(date_time_values._GetNumberOfDaysInYear(10100), 365)

    def testGetNumberOfSecondsFromElements(self):
        """Tests the _GetNumberOfSecondsFromElements function."""
        date_time_values = interface.DateTimeValues()

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            1970, 1, 1, 0, 1, 0
        )
        self.assertEqual(number_of_seconds, 60)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            2010, 8, 12, 0, 0, 0
        )
        self.assertEqual(number_of_seconds, 1281571200)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            2010, 8, 12, None, None, None
        )
        self.assertEqual(number_of_seconds, 1281571200)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            2010, 8, 12, 21, 6, 31
        )
        self.assertEqual(number_of_seconds, 1281647191)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            2012, 3, 5, 20, 40, 0
        )
        self.assertEqual(number_of_seconds, 1330980000)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            1601, 1, 2, 0, 0, 0
        )
        self.assertEqual(number_of_seconds, -11644387200)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            0, 1, 2, 0, 0, 0
        )
        self.assertEqual(number_of_seconds, -62167132800)

        number_of_seconds = date_time_values._GetNumberOfSecondsFromElements(
            2010, 8, 0, 24, 6, 31
        )
        self.assertIsNone(number_of_seconds)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(2010, 13, 12, 21, 6, 31)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(2010, 8, 32, 24, 6, 31)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(2010, 8, 12, 24, 6, 31)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(2010, 8, 12, 21, 99, 31)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(2010, 8, 12, 21, 6, 65)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(2013, 2, 29, 1, 4, 25)

        with self.assertRaises(ValueError):
            date_time_values._GetNumberOfSecondsFromElements(10000, 8, 12, 21, 6, 31)

    def testGetTimeValues(self):
        """Tests the _GetTimeValues function."""
        date_time_values = interface.DateTimeValues()

        days, hours, minutes, seconds = date_time_values._GetTimeValues(10)
        self.assertEqual(days, 0)
        self.assertEqual(hours, 0)
        self.assertEqual(minutes, 0)
        self.assertEqual(seconds, 10)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(190)
        self.assertEqual(days, 0)
        self.assertEqual(hours, 0)
        self.assertEqual(minutes, 3)
        self.assertEqual(seconds, 10)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(18190)
        self.assertEqual(days, 0)
        self.assertEqual(hours, 5)
        self.assertEqual(minutes, 3)
        self.assertEqual(seconds, 10)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(190990)
        self.assertEqual(days, 2)
        self.assertEqual(hours, 5)
        self.assertEqual(minutes, 3)
        self.assertEqual(seconds, 10)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(-10)
        self.assertEqual(days, -1)
        self.assertEqual(hours, 23)
        self.assertEqual(minutes, 59)
        self.assertEqual(seconds, 50)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(-190)
        self.assertEqual(days, -1)
        self.assertEqual(hours, 23)
        self.assertEqual(minutes, 56)
        self.assertEqual(seconds, 50)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(-18190)
        self.assertEqual(days, -1)
        self.assertEqual(hours, 18)
        self.assertEqual(minutes, 56)
        self.assertEqual(seconds, 50)

        days, hours, minutes, seconds = date_time_values._GetTimeValues(-190990)
        self.assertEqual(days, -3)
        self.assertEqual(hours, 18)
        self.assertEqual(minutes, 56)
        self.assertEqual(seconds, 50)

    def testIsLeapYear(self):
        """Tests the _IsLeapYear function."""
        date_time_values = interface.DateTimeValues()

        self.assertFalse(date_time_values._IsLeapYear(1999))
        self.assertTrue(date_time_values._IsLeapYear(2000))
        self.assertTrue(date_time_values._IsLeapYear(1996))


if __name__ == "__main__":
    unittest.main()
