Пример #1
0
    def test_fun(self):
        weekday = calculate(2017, 5, 8)
        self.assertEqual(weekday, 0)

        weekday = calculate(1648, 5, 8)
        self.assertEqual(weekday, 4)

        weekday = calculate(1790, 5, 8)
        self.assertEqual(weekday, 5)

        weekday = calculate(1000, 15, 1)
        self.assertEqual(weekday, -1)

        weekday = calculate(1000, 15, 0)
        self.assertEqual(weekday, -1)

        weekday = calculate(1000, 7, -13)
        self.assertEqual(weekday, -1)

        weekday = calculate(1000, 7, 40)
        self.assertEqual(weekday, -1)

        weekday = calculate(2000, 2, 30)
        self.assertEqual(weekday, -1)

        weekday = calculate(2000, -2, 30)
        self.assertEqual(weekday, -1)

        retcode = main(("--year", "2001", "--month", "1", "--day", "3"))
        self.assertEqual(retcode, 0)
        retcode = main(("--year", "2001", "--month", "1"))
        self.assertEqual(retcode, 1)
Пример #2
0
    def test_fun(self):
        weekday = calculate(2017, 5, 10)
        self.assertEqual(weekday, 2)

        weekday = calculate(2020, 2, 29)
        self.assertEqual(weekday, 6)

        weekday = calculate(2001, -1, 3)
        self.assertEqual(weekday, -1)

        weekday = calculate(2013, 13, 13)
        self.assertEqual(weekday, -1)

        weekday = calculate(2013, 'a', 13)
        self.assertEqual(weekday, -1)

        retcode3 = main(("--year", "2001", "--month", "1", "--day", "3", "abc", "sgsg"))
        self.assertEqual(retcode3, -1)

        retcode4 = main(("--year", "2020", "--month", "2", "--day", "29"))
        self.assertEqual(retcode4, 6)

        retcode5 = main(("--year", "1990", "--month", "2", "--day", "29"))
        self.assertEqual(retcode5, -1)

        retcode6 = main(("--year", "2017", "--month", "4", "--day", "31"))
        self.assertEqual(retcode6, -1)

        retcode7 = main(("--year", "2017", "--month", "5", "--day", "10"))
        self.assertEqual(retcode7, 2)
Пример #3
0
 def test_arg_parsing(self):
     self.assertRaises(
         argparse.ArgumentError,
         main(("--year", "201.5", "--month", "1", "--day", "2")))
     self.assertRaises(
         argparse.ArgumentError,
         main(("--year", "asdf", "--month", "1", "--day", "2")))
     self.assertRaises(
         argparse.ArgumentError,
         main(("--year", "2016", "--month", "{}", "--day", "3")))
Пример #4
0
    def test_fun(self):
        weekday = calculate(2001, 1, 3)
        self.assertEqual(weekday, 2005)

        retcode = main(("--year", "2001", "--month", "1", "--day", "3"))
        self.assertEqual(retcode, 0)

        retcode1 = main(("--ar", "2001", "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode1, 1)

        retcode2 = main(("--year", 2001, "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode2, 1)

        retcode3 = main(("--year", "2001", "--month", "1,2,3", "--day", "3"))
        self.assertNotEqual(retcode3, 1)

        retcode4 = main(("--year", "2001-22", "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode4, 1)

        retcode5 = main(("--year", "2001", "--th", "1", "--day", "3"))
        self.assertNotEqual(retcode5, 1)

        retcode6 = main(("--year", "2001", "--month", "1", "--day", "mama"))
        self.assertNotEqual(retcode6, 1)

        retcode7 = main(("--year", "2001", "--month", "marzec", "--day", "3"))
        self.assertNotEqual(retcode7, 1)
Пример #5
0
    def test_fun(self):
        weekday = calculate(2017, 5, 12)
        self.assertEqual(weekday, "Friday")

        weekday = calculate(2010, 6, 30)
        self.assertEqual(weekday, "Wednesday")

        weekday = calculate(2012, 2, 29)
        self.assertEqual(weekday, "Wednesday")

        weekday = calculate(2014, 2, 29)
        self.assertEqual(weekday, None)

        weekday = calculate(2100, 2, 29)
        self.assertEqual(weekday, None)

        retcode = main(("--year", "2001", "--month", "1", "--day", "3"))
        self.assertEqual(retcode, 0)

        retcode = main(("--year", "a2001", "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode, 0)

        retcode = main(("--year", "-2001", "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode, 0)
Пример #6
0
    def test_fun(self):
        # weekday = calculate(2001, 1, 3)
        # self.assertEqual(weekday, 2005)

        weekday = calculate(2001, 1, 3)
        self.assertEqual(weekday, 2)

        weekday = calculate(2000, 2, 29)
        self.assertEqual(weekday, 1)

        weekday = calculate(2000, 3, 1)
        self.assertEqual(weekday, 2)

        weekday = calculate(2001, 2, 29)
        self.assertEqual(weekday, None)

        weekday = calculate(2001, 3, 1)
        self.assertEqual(weekday, 3)

        weekday = calculate(2004, 2, 29)
        self.assertEqual(weekday, 6)

        weekday = calculate(2004, 3, 1)
        self.assertEqual(weekday, 6, 0)

        retcode = main(("--year", "2001", "--month", "1", "--day", "3"))
        self.assertEqual(retcode, 0)

        retcode = main(("--jahre", "2001", "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode, 0)

        retcode = main(("--month", "1", "--day", "3", "--year", "2001"))
        self.assertEqual(retcode, 0)

        retcode = main(("--year", "2001", "--month", "2", "--day", "30"))
        self.assertNotEqual(retcode, 0)

        retcode = main(("--year", "2001", "--month", "trzy", "--day", "30"))
        self.assertNotEqual(retcode, 0)

        retcode = main(("--year", "2001", "--day", "30"))
        self.assertNotEqual(retcode, 0)

        retcode = main(("--year", "-2001", "--month", "1", "--day", "3"))
        self.assertNotEqual(retcode, 0)
Пример #7
0
    def test_fun(self):

        weekday = calculate(2016, 2, 29)
        self.assertEqual(weekday, 0)
        weekday = calculate(2017, 3, 15)
        self.assertEqual(weekday, 2)
        weekday = calculate(2015, 2, 29)
        self.assertEqual(weekday, None)
        weekday = calculate(2016, 2, 30)
        self.assertEqual(weekday, None)
        weekday = calculate(2016, -2, 30)
        self.assertEqual(weekday, None)

        badArgsList = [
            ["--year", "2001", "--month", "-1", "--day", "3"],
            ["--year", "2001", "--monh", "1", "--day", "3"],
            ["--year", "2001", "--month", "1", "--day", "38"]
        ]

        for arg in badArgsList:
            retcode = main(arg)
            self.assertNotEqual(retcode, 0)
Пример #8
0
    def calculation_should_fail_out_of_date(self):
        weekday = calculate(2010, 5, 32)
        self.assertEqual(weekday, 1)

        retcode = main(("--year", "2010", "--month", "5", "--day", "32"))
        self.assertEqual(retcode, 1)
Пример #9
0
 def test_main_should_raise_an_error_when_provided_not_enough_args(self):
     self.assertRaises(argparse.ArgumentError,
                       main('--year 2000 --month 10'))
Пример #10
0
 def test_main_should_raise_an_error_for_empty_arguments(self):
     self.assertRaises(argparse.ArgumentError, main('--year --month --day'))
Пример #11
0
    def calculation_should_pass1(self):
        weekday = calculate(2017, 5, 10)
        self.assertEqual(weekday, 2)

        retcode = main(("--year", "2017", "--month", "5", "--day", "10"))
        self.assertEqual(retcode, 2)
Пример #12
0
    def calculation_should_test_leap_year(self):
        weekday = calculate(1996, 3, 1)
        self.assertEqual(weekday, 4)

        retcode = main(("--year", "1996", "--month", "3", "--day", "1"))
        self.assertEqual(retcode, 4)
Пример #13
0
 def test_main_should_raise_an_error_for_illegal_arguments(self):
     self.assertRaises(argparse.ArgumentError,
                       main('--year 2000 --month 10 --da 1'))
Пример #14
0
    def test_fun(self):
        weekday = calculate(2001, 1, 3)
        self.assertEqual(weekday, 2005)

        retcode = main(("--year", "2001", "--month", "1", "--day", "3"))
        self.assertEqual(retcode, 0)
Пример #15
0
    def calculation_should_fail_wrong_match(self):
        weekday = calculate(2013, 2, 1)
        self.assertEqual(weekday, 3)

        retcode = main(("--year", "2013", "--month", "2", "--day", "1"))
        self.assertEqual(retcode, 4)
Пример #16
0
    def calculation_should_pass2(self):
        weekday = calculate(2014, 1, 1)
        self.assertEqual(weekday, 2)

        retcode = main(("--year", "2014", "--month", "1", "--day", "1"))
        self.assertEqual(retcode, 2)
Пример #17
0
 def test_main_should_raise_an_error_for_non_integer_arguments(self):
     self.assertRaises(argparse.ArgumentError,
                       main('--year 2015 --month 8 --day hello'))
Пример #18
0
    def calculation_should_fail_wrong_arguments(self):
        weekday = calculate(2017, 5, 10)
        self.assertEqual(weekday, 2)

        retcode = main(("--year", "2010", "--monh", "5", "--day", "32"))
        self.assertEqual(retcode, 1)
Пример #19
0
 def test_main_should_return_0_for_legal_arguments(self):
     res = main('--year 2000 --month 10 --day 10')
     self.assertEqual(res, 0)