import unittest

class Testi(unittest.TestCase):
    def test_01_zaporedne_skupine(self):
        self.assertEqual(
            [[3, 4, 5], [8], [10, 11, 12, 13], [18, 19, 20]],
            zaporedne_skupine([3, 4, 5, 8, 10, 11, 12, 13, 18, 19, 20])
            )
        self.assertEqual([[3, 4, 5]], zaporedne_skupine([3, 4, 5]))
        s = list(range(10000))
        self.assertEqual([s], zaporedne_skupine(s))

    def test_01_zaporedni_intervali(self):
        self.assertEqual(
            [(3, 5), (8, 8), (10, 13), (18, 20)],
            zaporedni_intervali([3, 4, 5, 8, 10, 11, 12, 13, 18, 19, 20]))
        self.assertEqual([(3, 5)], zaporedni_intervali([3, 4, 5]))
        s = list(range(10000))
        self.assertEqual([(0, 9999)], zaporedni_intervali(s))

    def test_02_dodaj(self):
        original = [(3, 5), (8, 8), (10, 13), (18, 20)]

        intervali = original[:]
        self.assertIsNone(dodaj(0, intervali))
        self.assertEqual([(0, 0), (3, 5), (8, 8), (10, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(1, intervali))
        self.assertEqual([(1, 1), (3, 5), (8, 8), (10, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(2, intervali))
        self.assertEqual([(2, 5), (8, 8), (10, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(3, intervali))
        self.assertEqual(original, intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(4, intervali))
        self.assertEqual(original, intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(5, intervali))
        self.assertEqual(original, intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(6, intervali))
        self.assertEqual([(3, 6), (8, 8), (10, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(7, intervali))
        self.assertEqual([(3, 5), (7, 8), (10, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(8, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(9, intervali))
        self.assertEqual([(3, 5), (8, 13), (18, 20)], intervali)

        intervali = [(3, 4), (6, 8), (10, 13), (18, 20)]
        self.assertIsNone(dodaj(7, intervali))
        self.assertEqual([(3, 4), (6, 8), (10, 13), (18, 20)], intervali)

        intervali = [(3, 5), (8, 8), (12, 13), (18, 20)]
        self.assertIsNone(dodaj(9, intervali))
        self.assertEqual([(3, 5), (8, 9), (12, 13), (18, 20)], intervali)

        intervali = [(3, 5), (8, 9), (12, 13), (18, 20)]
        self.assertIsNone(dodaj(7, intervali))
        self.assertEqual([(3, 5), (7, 9), (12, 13), (18, 20)], intervali)

        intervali = [(3, 5), (8, 9), (12, 13), (18, 20)]
        self.assertIsNone(dodaj(10, intervali))
        self.assertEqual([(3, 5), (8, 10), (12, 13), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(14, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 14), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(15, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (15, 15), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(16, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (16, 16), (18, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(17, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (17, 20)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(18, intervali))
        self.assertEqual(original, intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(19, intervali))
        self.assertEqual(original, intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(20, intervali))
        self.assertEqual(original, intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(21, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (18, 21)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(22, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (18, 20), (22, 22)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(23, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (18, 20), (23, 23)], intervali)

        intervali = original[:]
        self.assertIsNone(dodaj(100, intervali))
        self.assertEqual([(3, 5), (8, 8), (10, 13), (18, 20), (100, 100)], intervali)

        intervali = [(1000000, 2000000), (2000002, 5000000), (10000000, 1000000000)]
        self.assertIsNone(dodaj(2000001, intervali))
        self.assertEqual([(1000000, 5000000), (10000000, 1000000000)], intervali)

        intervali = []
        self.assertIsNone(dodaj(42, intervali))
        self.assertEqual(intervali, [(42, 42)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(30, intervali))
        self.assertEqual(intervali, [(30, 30), (42, 42)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(40, intervali))
        self.assertEqual(intervali, [(40, 40), (42, 42)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(41, intervali))
        self.assertEqual(intervali, [(41, 42)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(42, intervali))
        self.assertEqual(intervali, [(42, 42)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(43, intervali))
        self.assertEqual(intervali, [(42, 43)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(44, intervali))
        self.assertEqual(intervali, [(42, 42), (44, 44)])

        intervali = [(42, 42)]
        self.assertIsNone(dodaj(100, intervali))
        self.assertEqual(intervali, [(42, 42), (100, 100)])

        intervali = [(42, 42), (44, 44)]
        self.assertIsNone(dodaj(43, intervali))
        self.assertEqual(intervali, [(42, 44)])


    def test_03_nepalindrom(self):
        self.assertEqual(nepalindrom("abcba"), 0)
        self.assertEqual(nepalindrom("abba"), 0)
        self.assertEqual(nepalindrom("aa"), 0)
        self.assertEqual(nepalindrom(""), 0)

        self.assertEqual(0, nepalindrom("abcdefedcba"))
        self.assertEqual(1, nepalindrom("abcdefedcbs"))
        self.assertEqual(1, nepalindrom("abcdefedcsa"))
        self.assertEqual(2, nepalindrom("abcdefsdcsa"))
        self.assertEqual(2, nepalindrom("abcdefsdcsa"))
        self.assertEqual(3, nepalindrom("tbcdefsdcsa"))

    def test_04_slovar_intervalov(self):
        s = slovar_intervalov([3, 4, 5, 8, 10, 11, 12, 13, 18, 19, 20])
        self.assertEqual((3, 5), s[3])
        self.assertEqual((3, 5), s[4])
        self.assertEqual((3, 5), s[5])
        self.assertEqual((8, 8), s[8])
        self.assertEqual((10, 13), s[10])
        self.assertEqual((10, 13), s[11])
        self.assertEqual((10, 13), s[12])
        self.assertEqual((10, 13), s[13])
        with self.assertRaises(KeyError):
            s[1]
        with self.assertRaises(KeyError):
            s[2]
        with self.assertRaises(KeyError):
            s[6]
        with self.assertRaises(KeyError):
            s[9]
        with self.assertRaises(KeyError):
            s[25]

    def test_05_macek(self):
        m = Macek()
        self.assertEqual(0, m.sitost())
        m.pojej_mis()
        self.assertEqual(0, m.sitost())
        m.shrani_mis(13)
        self.assertEqual(0, m.sitost())
        m.shrani_mis(42)
        self.assertEqual(0, m.sitost())
        m.pojej_mis()
        self.assertEqual(42, m.sitost())
        m.shrani_mis(10)
        self.assertEqual(42, m.sitost())
        m.shrani_mis(22)
        self.assertEqual(42, m.sitost())
        m.pojej_mis()
        self.assertEqual(42 + 22, m.sitost())
        m.pojej_mis()
        self.assertEqual(42 + 22 + 10, m.sitost())
        m.shrani_mis(5)
        self.assertEqual(42 + 22 + 10, m.sitost())
        m.pojej_mis()
        self.assertEqual(42 + 22 + 10 + 5, m.sitost())
        m.pojej_mis()
        self.assertEqual(42 + 22 + 10 + 5 + 13, m.sitost())
        m.pojej_mis()
        self.assertEqual(42 + 22 + 10 + 5 + 13, m.sitost())


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