import unittest


class Test01(unittest.TestCase):
    def test_tocen_opcijsko(self):
        self.assertTrue(tocen([570, 590, 616, 620], [570, 590, 616, 620]))
        self.assertTrue(tocen([570, 590, 616, 620], [574, 610, 636, 640]))

        self.assertFalse(tocen([570, 590, 616, 620], [591, 590, 616, 620]))
        self.assertFalse(tocen([570, 590, 616, 620], [570, 611, 616, 620]))
        self.assertFalse(tocen([570, 590, 616, 620], [570, 590, 616, 641]))

    def test_tocni(self):
        self.assertEqual(0, tocni([], []))
        self.assertEqual(1, tocni([[570, 590, 616, 620]],
                                  [[570, 590, 616, 620]]))
        self.assertEqual(0, tocni([[570, 590, 616, 620]],
                                  [[570, 611, 616, 620]]))
        self.assertEqual(2, tocni([[570, 590, 616, 620], [1200, 1500], [800, 900, 1000], [700, 800]],
                                  [[570, 611, 616, 620], [1200, 1510], [810, 910, 1000], [800, 900]]))


class Test02(unittest.TestCase):
    def test_enaki(self):
        # Čisto enaki
        self.assertTrue(enaki(["A", "C", "D", "F", "G"],
                              ["A", "C", "D", "F", "G"]))

        # Druga je hitrejša
        self.assertTrue(enaki(["A", "C", "D", "F", "G"],
                              ["A", "G"]))
        self.assertTrue(enaki(["A", "C", "D", "F", "G"],
                              ["A", "D", "G"]))
        self.assertTrue(enaki(["A", "C", "D", "F", "G"],
                              ["A", "D", "F", "G"]))
        self.assertTrue(enaki(["A", "C", "D", "F", "G"],
                              ["A", "D", "G"]))
        self.assertTrue(enaki(["A", "C", "D", "F", "G"],
                              ["A", "C", "G"]))

        # Prva je hitrejša
        self.assertTrue(enaki(["A", "G"],
                              ["A", "C", "D", "F", "G"]))
        self.assertTrue(enaki(["A", "D", "G"],
                              ["A", "C", "D", "F", "G"]))
        self.assertTrue(enaki(["A", "D", "F", "G"],
                              ["A", "C", "D", "F", "G"]))

        # Pomešan red
        self.assertTrue(enaki(["A", "C", "F", "D", "G"],
                              ["A", "C", "D", "F", "G"]))
        self.assertTrue(enaki(["A", "C", "F", "D", "G"],
                              ["A", "D", "F", "G"]))

        # Neenaki končni postaji
        self.assertFalse(enaki(["A", "C", "D", "F", "G"],
                               ["A", "C", "D", "F"]))
        self.assertFalse(enaki(["A", "C", "D", "F"],
                               ["A", "C", "D", "F", "G"]))

        # Ena ima postajo, ki je druga nima in tudi obratno
        self.assertFalse(enaki(["A", "C", "G"],
                               ["A", "D", "G"]))
        self.assertFalse(enaki(["A", "C", "E", "F", "G"],
                               ["A", "D", "E", "G"]))
        self.assertFalse(enaki(["A", "B", "C", "E", "F", "G"],
                               ["A", "B", "C", "D", "E", "G"]))
        self.assertFalse(enaki(["A", "C", "D", "G"],
                               ["A", "D", "F", "G"]))


class Test03(unittest.TestCase):
    def test_zamujenih(self):
        cakajoci = {
            "LP0001": ["LP1256", "LP1682", "LP3682"],
            "LP3416": [],
            "LP8722": [],
            "LP6316": [],
            "LP1682": [],
            "LP3682": ["LP8524", "IC021"],
            "IC204": [],
            "LP8524": ["EN123", "IC521", "LP6316"],
            "LP5567": [],
            "LP2222": ["EN753"],
            "IC021": ["LP2222", "IC204"],
            "LP5568": ["LP8722", "LP3416", "LP8721"],
            "IC521": ["LP5567", "LP5568"],
            "EN123": [],
            "EN753": [],
            "LP1256": ["EN456"],
            "LP8721": [],
            "LP1212": [],
            "EN456": ["LP1212"],
        }

        self.assertEqual(14, zamujenih("LP3682", cakajoci))
        self.assertEqual(1, zamujenih("LP3416", cakajoci))
        self.assertEqual(1, zamujenih("LP3682", {"LP3682": set(), "LP1234": {"LP3682"}}))


class Test04(unittest.TestCase):
    def test_v_minute(self):
        self.assertEqual(708, v_minute((11, 48)))
        self.assertEqual(0, v_minute((0, 0)))
        self.assertEqual(690, v_minute((11, 30)))
        self.assertEqual(670, v_minute((11, 10)))

    def test_v_cas(self):
        self.assertEqual((11, 48), v_cas(708))
        self.assertEqual((0, 0), v_cas(0))
        self.assertEqual((11, 30), v_cas(690))
        self.assertEqual((11, 10), v_cas(670))

    def test_raztegni(self):
        self.assertEqual((12, 59), raztegni((11, 48)))


class Test05(unittest.TestCase):
    def test_sprevodnik(self):
        sprevodnik = Sprevodnik("A",
                                {("A", "B"): 3,
                                 ("A", "C"): 5,
                                 ("A", "D"): 8,
                                 ("A", "E"): 12,
                                 ("B", "C"): 3,
                                 ("B", "D"): 6,
                                 ("B", "E"): 10,
                                 ("C", "D"): 4,
                                 ("C", "E"): 8,
                                 ("D", "E"): 5
                                 })
        self.assertEqual(0, sprevodnik.blagajna())
        self.assertEqual(0, sprevodnik.potnikov())
        sprevodnik.potnik("C")  # smo na A, karta stane 5
        self.assertEqual(5, sprevodnik.blagajna())  # sprevodnik ima 5
        self.assertEqual(1, sprevodnik.potnikov())
        sprevodnik.potnik("E")  # smo na A, karta stane 12
        self.assertEqual(17, sprevodnik.blagajna())  # sprevodnik ima 17
        self.assertEqual(2, sprevodnik.potnikov())

        sprevodnik.postaja("B")  # smo na B
        self.assertEqual(17, sprevodnik.blagajna())  # še vedno ima 17
        self.assertEqual(2, sprevodnik.potnikov())
        sprevodnik.potnik("C")  # smo na B, karta stane 3
        self.assertEqual(20, sprevodnik.blagajna())
        self.assertEqual(3, sprevodnik.potnikov())

        sprevodnik.postaja("C")  # smo na C -> dva potnika izstopita
        self.assertEqual(20, sprevodnik.blagajna())
        self.assertEqual(1, sprevodnik.potnikov())

        sprevodnik.postaja("D")  # smo na D -> nič novega
        self.assertEqual(20, sprevodnik.blagajna())
        self.assertEqual(1, sprevodnik.potnikov())

        sprevodnik.postaja("E")  # smo na C -> še en potnik izstopi
        self.assertEqual(20, sprevodnik.blagajna())
        self.assertEqual(0, sprevodnik.potnikov())


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