import unittest

class Test(unittest.TestCase):
    def test_dovoljeno(self):
        self.assertEqual(4, dovoljeno([(5, 10), (0, 3)]))
        self.assertEqual(11, dovoljeno([(5, 10), (0, 3), (7, 9), (2, 8)]))
        self.assertEqual(0, dovoljeno([(5, 10), (2, 3), (7, 9), (2, 8)]))
        self.assertEqual(11, dovoljeno([(5, 10), (0, 3), (15, 20), (7, 9), (2, 8)]))

        t = [(5, 10), (0, 3), (15, 20), (7, 9), (2, 8)]
        self.assertEqual(11, dovoljeno(t))
        self.assertEqual(t, [(5, 10), (0, 3), (15, 20), (7, 9), (2, 8)],
                         "Funkcija ne sme spreminjati podanega seznama")

    def test_reke(self):
        def v_mnozice(pritoki):
            return set((reka, frozenset(prireke)) for reka, prireke in pritoki)

        pritoki = reke([("Nadiža", "Soča"), ("Sora", "Sava"), ("Savinja", "Sava"),
                        ("Mura", "Drava"), ("Drava", "Donava"), ("Sava", "Donava"),
                        ("Ljubljanica", "Sava"), ("Kamniška Bistrica", "Sava")])

        pravilno = [("Sava", ["Sora", "Savinja", "Ljubljanica", "Kamniška Bistrica"]),
                    ("Donava", ["Drava", "Sava"]),
                    ("Soča", ["Nadiža"]),
                    ("Drava", ["Mura"])]

        # Test pretvori oboje v množice -- samo zato, da je vseeno, v kakšnem
        # vrstnem redu vaša funkcija vrne reke. Funkcija mora vrniti to, kar
        # je zgoraj v seznamu `pravilno` (le vrstni red je lahko drugačen)
        self.assertEqual(v_mnozice(pravilno), v_mnozice(pritoki))

        # Spodnji test pa naredi 69904 rek, da vidimo, ali ste res dobro
        # napisali svojo funkcijo
        vodotok = []
        pravilno = set()
        def sestavi(s):
            if len(s) < 5:
                pritoki = []
                for nasl in "abcdefghijklmnop":
                    vodotok.append((s + nasl, s))
                    sestavi(s + nasl)
                    pritoki.append(s + nasl)
                pravilno.add((s, frozenset(pritoki)))

        sestavi("A")
        self.assertEqual(pravilno, v_mnozice(reke(vodotok)))

    def test_ujemanja(self):
        self.assertEqual({2, 6, 8}, ujemanja([5, 1, 2, 6, 7, 6, 8, 4],
                                             [4, 4, 2, 6, 5, 2, 8, 3]))
        self.assertEqual({2, 6, 8}, ujemanja([5, 1, 2, 6, 7, 6, 8, 4, 12],
                                             [4, 4, 2, 6, 5, 2, 8, 3]))
        self.assertEqual({2, 6, 8}, ujemanja([5, 1, 2, 6, 7, 6, 8, 4],
                                             [4, 4, 2, 6, 5, 2, 8, 3, 12]))

        t = [5, 1, 2, 6, 7, 6, 8, 4]
        s = [4, 4, 2, 6, 5, 2, 8, 3, 12]
        self.assertEqual({2, 6, 8}, ujemanja(t, s))
        self.assertEqual(t, [5, 1, 2, 6, 7, 6, 8, 4],
                         "Funkcija ne sme spreminjati podanega seznama")
        self.assertEqual(s, [4, 4, 2, 6, 5, 2, 8, 3, 12],
                         "Funkcija ne sme spreminjati podanega seznama")

        self.assertEqual({2}, ujemanja([2], [2]))
        self.assertEqual(set(), ujemanja([2, 3, 4], []))

    def test_parkirna_hisa(self):
        hisa = ParkirnaHisa(4)

        self.assertEqual(0, hisa.zasedenost())
        self.assertEqual(0, hisa.prihod("LJ 12345", 5))
        self.assertEqual(1, hisa.zasedenost())
        self.assertEqual(1, hisa.prihod("LJ 23456", 8))
        self.assertEqual(2, hisa.zasedenost())
        self.assertEqual(2, hisa.prihod("LJ 34566", 12))
        self.assertEqual(3, hisa.zasedenost())
        self.assertEqual(10, hisa.odhod("LJ 23456", 18))
        self.assertEqual(2, hisa.zasedenost())
        self.assertEqual(1, hisa.prihod("LJ 67890", 20))
        self.assertEqual(3, hisa.zasedenost())
        self.assertEqual(3, hisa.prihod("LJ 45678", 21))
        self.assertEqual(4, hisa.zasedenost())
        self.assertIsNone(hisa.prihod("KR 67890", 22))

    def test_interpolacija(self):
        self.assertEqual([3, 5, 2, 4, 6, 1],
                         interpolacija([3, 5, 2, None, 6, 1]))

        t = [3, 5, 2, None, 6, 1]
        self.assertEqual([3, 5, 2, 4, 6, 1],
                         interpolacija(t))
        self.assertEqual([3, 5, 2, None, 6, 1], t,
                         "Funkcija ne sme spreminjati podanega seznama!")

        self.assertEqual([3, 5, 2, 4, 4, 4, 6, 1],
                         interpolacija([3, 5, 2, None, None, None, 6, 1]))

        self.assertEqual([3, 5, 2, 4, 4, 4, 6, 7, 8, 1],
                         interpolacija([3, 5, 2, None, None, None, 6, None, 8, 1]))

        self.assertEqual([5, 5, 2, 6, 1],
                         interpolacija([None, 5, 2, 6, 1]))

        self.assertEqual([5, 5, 5, 5, 2, 6, 1],
                         interpolacija([None, None, None, 5, 2, 6, 1]))

        self.assertEqual([3, 5, 2, 6, 1, 1, 1],
                         interpolacija([3, 5, 2, 6, 1, None, None]))

        self.assertEqual([3, 3, 5, 2, 4, 4, 4, 4, 6, 1, 1, 1],
                         interpolacija([None, 3, 5, 2, None, None, None, None, 6, 1, None, None]))


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