import unittest
class TestPostar(unittest.TestCase):
    def test_pari_his(self):
        self.assertSetEqual(pari_his(
            [11, 19, 29, 36, 40, 44, 52, 61, 70, 74, 83]),
            {(83, 36), (36, 83), (36, 61), (61, 36), (61, 11), (11, 61),
             (61, 19), (19, 61), (11, 19), (19, 11), (19, 29), (29, 19),
             (29, 52), (52, 29),
             (70, 74), (74, 70), (74, 44), (44, 74),
             (44, 40), (40, 44), (40, 70), (70, 40),
             (40, 74), (74, 40)})

        self.assertSetEqual(pari_his([]), set())
        self.assertSetEqual(pari_his([44]), set())
        self.assertSetEqual(pari_his([34, 54]), {(34, 54), (54, 34)})
        self.assertSetEqual(pari_his([43, 54]), {(43, 54), (54, 43)})
        self.assertSetEqual(pari_his([43, 45]), {(43, 45), (45, 43)})
        self.assertSetEqual(pari_his(
            [1234, 5678, 790]),
            {(5678, 790), (790, 5678)})
        self.assertSetEqual(pari_his(
            [1234, 5678, 7901]),
            {(5678, 7901), (7901, 5678), (1234, 7901), (7901, 1234)})
        self.assertSetEqual(pari_his(
            [12, 34, 56, 78, 23, 45]),
            {(12, 23), (23, 34), (34, 45), (45, 56),
             (23, 12), (34, 23), (45, 34), (56, 45)})

        self.assertSetEqual(pari_his(
            [12, 23, 52, 44, 16, 68]),
            {(12, 23), (12, 52), (12, 16),
             (23, 12), (23, 52),
             (52, 12), (52, 23),
             (16, 12), (16, 68),
             (68, 16)})

    def test_legalna_pot(self):
        povezave = {(12, 23), (23, 34), (34, 45), (45, 56),
                    (23, 12), (34, 23), (45, 34), (56, 45)}
        self.assertTrue(legalna_pot([], povezave))
        self.assertTrue(legalna_pot([12], povezave))
        self.assertTrue(legalna_pot([1234], povezave))
        self.assertTrue(legalna_pot([12, 23, 34, 45], povezave))
        self.assertTrue(legalna_pot([23, 12, 23, 12], povezave))
        self.assertTrue(legalna_pot([23, 12, 23, 34, 45], povezave))

        self.assertFalse(legalna_pot([12, 34], povezave))
        self.assertFalse(legalna_pot([12, 23, 45, 56], povezave))
        self.assertFalse(legalna_pot([12, 34, 45, 56], povezave))
        self.assertFalse(legalna_pot([12, 23, 34, 56], povezave))

        # Ta ni legalna, ker para ni v povezavah
        self.assertFalse(legalna_pot([12, 23, 36, 56], povezave))

    def test_legalna_pot_bp(self):
        povezave = {(12, 23), (23, 34), (34, 45), (45, 56),
                    (23, 12), (34, 23), (45, 34), (56, 45)}
        self.assertTrue(legalna_pot_bp([], povezave))
        self.assertTrue(legalna_pot_bp([12], povezave))
        self.assertTrue(legalna_pot_bp([1234], povezave))
        self.assertTrue(legalna_pot_bp([12, 23, 34, 45], povezave))

        self.assertFalse(legalna_pot_bp([23, 12, 23, 12], povezave))
        self.assertFalse(legalna_pot_bp([23, 12, 23, 34, 45], povezave))

        self.assertFalse(legalna_pot_bp([12, 34], povezave))
        self.assertFalse(legalna_pot_bp([12, 23, 45, 56], povezave))
        self.assertFalse(legalna_pot_bp([12, 34, 45, 56], povezave))
        self.assertFalse(legalna_pot_bp([12, 23, 34, 56], povezave))

    def test_graf_stevilk(self):
        self.assertDictEqual(graf_stevilk(
            {(83, 36), (36, 83), (36, 61), (61, 36), (61, 11), (11, 61),
             (61, 19), (19, 61), (11, 19), (19, 11), (19, 29), (29, 19),
             (29, 52), (52, 29),
             (70, 74), (74, 70), (74, 44), (44, 74),
             (44, 40), (40, 44), (40, 70), (70, 40),
             (40, 74), (74, 40)}),
            {83: {36},
             36: {83, 61},
             61: {36, 11, 19},
             11: {61, 19},
             19: {61, 29, 11},
             29: {19, 52},
             52: {29},
             70: {74, 40},
             74: {70, 44, 40},
             44: {74, 40},
             40: {70, 44, 74}})

        self.assertDictEqual(graf_stevilk(set()), {})
        self.assertDictEqual(graf_stevilk({(1, 2), (2, 1)}), {1: {2}, 2: {1}})
        self.assertDictEqual(graf_stevilk(
            {(1, 2), (1, 3), (1, 4), (1, 5),
             (2, 1), (3, 1), (4, 1), (5, 1)}),
            {1: {2, 3, 4, 5}, 2: {1}, 3: {1}, 4: {1}, 5: {1}})

        # Ta ima "slucajno" usmerjen graf ... ampak hocem, da dela!
        self.assertDictEqual(graf_stevilk({(1, 2)}), {1: {2}})

    def test_dosegljivi(self):
        graf = {
            83: {36},
            36: {83, 61},
            61: {36, 11, 19},
            11: {61, 19},
            19: {61, 29, 11},
            29: {19, 52},
            52: {29},
            70: {74, 40},
            74: {70, 44, 40},
            44: {74, 40},
            40: {70, 44, 74},
            99: set()}
        self.assertSetEqual(dosegljivi(83, graf), {83, 36, 61, 11, 19, 29, 52})
        self.assertSetEqual(dosegljivi(36, graf), {83, 36, 61, 11, 19, 29, 52})
        self.assertSetEqual(dosegljivi(19, graf), {83, 36, 61, 11, 19, 29, 52})
        self.assertSetEqual(dosegljivi(70, graf), {70, 74, 40, 44})
        self.assertSetEqual(dosegljivi(99, graf), {99})


    def test_najdaljsa_pot_od(self):
        graf = {
            83: {36},
            36: {83, 61},
            61: {36, 11, 19},
            11: {61, 19},
            19: {61, 29, 11},
            29: {19, 52},
            52: {29},
            70: {74, 40},
            74: {70, 44, 40},
            44: {74, 40},
            40: {70, 44, 74},
            99: set()}
        self.assertEqual(najdaljsa_pot_od(83, graf),
                         [83, 36, 61, 11, 19, 29, 52])
        self.assertEqual(najdaljsa_pot_od(61, graf),
                         [61, 11, 19, 29, 52])
        self.assertTrue(najdaljsa_pot_od(74, graf) == [74, 44, 40, 70] or
                        najdaljsa_pot_od(74, graf) == [74, 70, 40, 44])

    def test_najdaljsa_pot(self):
        graf = {
            83: {36},
            36: {83, 61},
            61: {36, 11, 19},
            11: {61, 19},
            19: {61, 29, 11},
            29: {19, 52},
            52: {29},
            70: {74, 40},
            74: {70, 44, 40},
            44: {74, 40},
            40: {70, 44, 74},
            99: set()}
        resitev = [83, 36, 61, 11, 19, 29, 52]
        rezultat = najdaljsa_pot(graf)
        self.assertTrue(rezultat == resitev or rezultat == reversed(resitev))