import unittest


class TestZaba(unittest.TestCase):
    def test_zaba(self):
        self.assertEqual(zaba([("S", 5)]), {(0, 0), (0, 5)})
        self.assertEqual(zaba([("J", 5)]), {(0, 0), (0, -5)})
        self.assertEqual(zaba([("V", 5)]), {(0, 0), (-5, 0)})
        self.assertEqual(zaba([("Z", 5)]), {(0, 0), (5, 0)})
        self.assertEqual(zaba([("Z", 5), ("S", 2), ("J", 4)]),
                         {(0, 0), (5, 0), (5, 2), (5, -2)})
        self.assertEqual(zaba([("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                               ("S", 2), ("Z", 3)]),
                         {(0, 0), (5, 0), (5, 2), (1, 0), (1, 2),  (4, 2)})
        self.assertSetEqual(zaba([]), {(0, 0)})

    def test_znotraj(self):
        self.assertTrue(zaba_znotraj([("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                                      ("S", 2), ("Z", 3)],
                                     10, 10))
        self.assertTrue(zaba_znotraj([("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                                      ("S", 2), ("Z", 3)],
                                     5, 4))
        self.assertTrue(zaba_znotraj([], 5, 4))
        self.assertTrue(zaba_znotraj([], 0, 0))

        self.assertFalse(zaba_znotraj([("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                                       ("S", 2), ("Z", 3)],
                                      2, 4))

        self.assertFalse(zaba_znotraj([("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                                       ("S", 2), ("Z", 3)],
                                      5, 1))

        self.assertFalse(zaba_znotraj([("Z", 5), ("S", -2), ("J", 2), ("V", 4),
                                       ("S", 2), ("Z", 3)],
                                      5, 1))

        self.assertFalse(zaba_znotraj([("Z", 5), ("S", 2), ("J", 4), ("V", 4),
                                       ("S", 2), ("Z", 3)],
                                      5, 1))

    def test_naj_razdalja(self):
        from math import sqrt
        self.assertEqual(naj_razdalja([]), 0)
        self.assertAlmostEqual(naj_razdalja([("Z", 5), ("S", 2), ("J", 2),
                                             ("V", 4), ("S", 2), ("Z", 3)]),
                               sqrt(29))

    def test_muhe(self):
        self.assertEqual(muhe({(1, 0)},
                              [("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                               ("S", 2), ("Z", 3)]),
                         1)
        self.assertEqual(muhe({(1, 0), (10, 10)},
                              [("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                               ("S", 2), ("Z", 3)]),
                         1)
        self.assertEqual(muhe({(1, 0), (0, 0), (10, 10)},
                              [("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                               ("S", 2), ("Z", 3)]),
                         2)
        self.assertEqual(muhe({(1, 0), (0, 0), (5, 0), (10, 10)},
                              [("Z", 5), ("S", 2), ("J", 2), ("V", 4),
                               ("S", 2), ("Z", 3)]),
                         3)


class TestNaprejNazaj(unittest.TestCase):
    def test_naprej_nazaj(self):
        self.assertTrue(naprej_nazaj(""))
        self.assertTrue(naprej_nazaj("SJ"))
        self.assertTrue(naprej_nazaj("VZ"))
        self.assertTrue(naprej_nazaj("ZV"))
        self.assertTrue(naprej_nazaj("JS"))
        self.assertTrue(naprej_nazaj("JJVZSJVZSS"))

        self.assertFalse(naprej_nazaj("S"))
        self.assertFalse(naprej_nazaj("J"))
        self.assertFalse(naprej_nazaj("V"))
        self.assertFalse(naprej_nazaj("Z"))
        self.assertFalse(naprej_nazaj("JJ"))
        self.assertFalse(naprej_nazaj("JV"))
        self.assertFalse(naprej_nazaj("JZ"))
        self.assertFalse(naprej_nazaj("SJJ"))
        self.assertFalse(naprej_nazaj("SZJ"))


class TestRestavracija(unittest.TestCase):
    def test_zberi(self):
        self.assertDictEqual(zberi({"Rega": {"mušji kraki", "pajek"}}),
                             {"mušji kraki": 1, "pajek": 1})
        self.assertDictEqual(zberi({"Rega": {"mušji kraki", "pajek"},
                                    "Kvakica": {"mušji kraki"},
                                    "Dolgokrak": {"komarjev biftek"},
                                    "Zelena kvaka": {"pajek", "mušji kraki"}}),
                             {"mušji kraki": 3, "pajek": 2, "komarjev biftek": 1})
        self.assertDictEqual(zberi({"Rega": {"mušji kraki", "pajek"},
                                    "Kvakica": set()}),
                             {"mušji kraki": 1, "pajek": 1})
        self.assertDictEqual(zberi({"Rega": set()}), {})
        self.assertDictEqual(zberi({}), {})


class TestClassZaba(unittest.TestCase):
    def test_class_zaba(self):
        zaba = Zaba()
        self.assertTupleEqual(zaba.pozicija(), (0, 0))
        self.assertEqual(zaba.skupna_pot(), 0)
        zaba.sever(5)
        self.assertTupleEqual(zaba.pozicija(), (0, 5))
        self.assertEqual(zaba.skupna_pot(), 5)
        zaba.zahod(2)
        self.assertTupleEqual(zaba.pozicija(), (2, 5))
        self.assertEqual(zaba.skupna_pot(), 7)
        zaba.vzhod(4)
        self.assertTupleEqual(zaba.pozicija(), (-2, 5))
        self.assertEqual(zaba.skupna_pot(), 11)
        zaba.zahod(6)
        self.assertTupleEqual(zaba.pozicija(), (4, 5))
        self.assertEqual(zaba.skupna_pot(), 17)
        zaba.jug(16)
        self.assertTupleEqual(zaba.pozicija(), (4, -11))
        self.assertEqual(zaba.skupna_pot(), 33)


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