diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml index 105ce2d..dd4c951 100644 --- a/.idea/inspectionProfiles/profiles_settings.xml +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -1,5 +1,6 @@ + diff --git a/program.py b/program.py index b64d800..cc7c93a 100644 --- a/program.py +++ b/program.py @@ -1 +1,102 @@ -print("to je celotna reč") \ No newline at end of file +def pravilna(povezava): + x0, y0, x1, y1 = povezava + # preveri dolzino + prekratka = (abs(x1-x0) + abs(y1-y0)) > 0 + + # preveri, da je vodoravna ali navpicna in ne diagonalna + diagonalna = (x0 == x1) or (y0 == y1) + + return prekratka and diagonalna + +def pravilne(povezave): + for i in povezave: + if not pravilna(i): + return False + + return True + +def urejena(povezava): + x0, y0, x1, y1 = povezava + + if x1 < x0 or y1 < y0: + return x1, y1, x0, y0 + + return povezava + +def na_povezavi(x, y, povezava): + x0, y0, x1, y1 = urejena(povezava) + + return x0 <= x <= x1 and y0 <= y <= y1 + +def povezave_tocke(x, y, povezave): + r = set() + + for i in povezave: + if na_povezavi(x, y, i): + r.add(urejena(i)) + + return r + +def generiraj_tuples_povezava(povezava): + pov = [] + z0 = None + z1 = None + + x0, y0, x1, y1 = povezava + + if x0 == x1: + z0 = y0 + z1 = y1 + else: + z0 = x0 + z1 = x1 + + for ipsilon in range(z0, z1 + 1): + r = (x0, ipsilon) + pov.append(r) + + return pov + +def secisce(povezava1, povezava2): + if not pravilna(povezava1) and not pravilna(povezava2): return None + + povezava1 = urejena(povezava1) + povezava2 = urejena(povezava2) + + pov1 = generiraj_tuples_povezava(urejena(povezava1)) + pov2 = generiraj_tuples_povezava(urejena(povezava2)) + + + + + + print(povezava1) + print(pov1) + + +def main(): + povezave = [ + (11, 10, 13, 10), + + (2, 12, 8, 12), + (6, 11, 6, 13), + + (0, 16, 10, 16), + (3, 18, 3, 13), + (7, 14, 3, 14), + (9, 17, 9, 14), + ] + # 6 + # print(pravilna((18, 5, 13, 5))) + # print(pravilna((5, 18, 5, 13))) + # print(pravilna((10, 18, 12, 4))) + # print(pravilna((10, 18, 10, 18))) + + # na_povezavi(10, 19, (10, 22, 10, 20)) + + # print(povezave_tocke(3, 15, povezave)) + + print(secisce((10, 20, 10, 25), (8, 22, 18, 22))) + # print(secisce((8, 20, 18, 20), (1, 25, 0, 25))) + +main() \ No newline at end of file diff --git a/testi.py b/testi.py new file mode 100644 index 0000000..650eced --- /dev/null +++ b/testi.py @@ -0,0 +1,435 @@ +from program import * + +import unittest +import ast +from xml.dom import minidom + +povezave = [ + (11, 10, 13, 10), + + (2, 12, 8, 12), + (6, 11, 6, 13), + + (0, 16, 10, 16), + (3, 18, 3, 13), + (7, 14, 3, 14), + (9, 17, 9, 14), + (13, 15, 8, 15), + (12, 14, 12, 17), + (13, 16, 21, 16), + (14, 18, 14, 15), + (13, 15, 13, 16), + (16, 16, 16, 10), + (16, 10, 21, 10), + (14, 18, 10, 18), + (11, 13, 11, 20), + (15, 13, 22, 13), + (17, 15, 17, 17), + (18, 17, 18, 14), + (19, 19, 22, 19), + (20, 15, 20, 17), + (21, 10, 21, 19), +] + + +class TestOneLineMixin: + functions = { + elm.name: elm + for elm in ast.parse(open(__file__, "r", encoding="utf-8").read()).body + if isinstance(elm, ast.FunctionDef)} + + def assert_is_one_line(self, func): + body = self.functions[func.__code__.co_name].body + self.assertEqual(len(body), 1, "\nFunkcija ni dolga le eno vrstico") + self.assertIsInstance(body[0], ast.Return, "\nFunkcija naj bi vsebovala le return") + + def test_nedovoljene_funkcije(self): + dovoljene_funkcije = { + "pravilna", "pravilne", "urejena", "na_povezavi", + "povezave_tocke", "secisce", "krizisca", "mozna_pot", + "razdalja", "svg", "povezane", "dostopne", "pot"} + for func in self.functions: + self.assertIn(func, dovoljene_funkcije, f"\nFunkcija {func} ni dovoljena.") + + +class Test06(unittest.TestCase): + def test_01_pravilna(self): + self.assertTrue(pravilna((10, 20, 10, 22))) + self.assertTrue(pravilna((10, 22, 10, 20))) + self.assertTrue(pravilna((13, 5, 18, 5))) + self.assertTrue(pravilna((18, 5, 13, 5))) + + # Ni OK: spremenita se obe koordinati + self.assertFalse(pravilna((10, 18, 12, 4))) + self.assertFalse(pravilna((18, 10, 4, 12))) + self.assertFalse(pravilna((10, 20, 10, 20))) + + # Ni OK: ne spremeni se nobena koordinata + self.assertFalse(pravilna((10, 12, 10, 12))) + + def test_02_pravilne(self): + self.assertTrue(pravilne(povezave)) + self.assertTrue(pravilne([(1, 5, 1, 8)])) + self.assertTrue(pravilne([(1, 5, 2, 5)])) + + self.assertFalse(pravilne(povezave + [(10, 10, 10, 10)])) + self.assertFalse(pravilne([(10, 10, 10, 10)] + povezave)) + self.assertFalse(pravilne(povezave + [(10, 18, 12, 4)])) + self.assertFalse(pravilne([(10, 18, 12, 4)] + povezave)) + + def test_03_urejena(self): + self.assertEqual((10, 20, 10, 22), urejena((10, 20, 10, 22))) + self.assertEqual((10, 20, 10, 22), urejena((10, 22, 10, 20))) + self.assertEqual((13, 5, 18, 5), urejena((13, 5, 18, 5))) + self.assertEqual((13, 5, 18, 5), urejena((18, 5, 13, 5))) + + def test_04_na_povezavi(self): + self.assertTrue(na_povezavi(10, 20, (10, 20, 10, 22))) + self.assertTrue(na_povezavi(10, 21, (10, 20, 10, 22))) + self.assertTrue(na_povezavi(10, 22, (10, 20, 10, 22))) + self.assertTrue(na_povezavi(10, 20, (10, 22, 10, 20))) + self.assertTrue(na_povezavi(10, 21, (10, 22, 10, 20))) + self.assertTrue(na_povezavi(10, 22, (10, 22, 10, 20))) + self.assertFalse(na_povezavi(10, 23, (10, 22, 10, 20))) + self.assertFalse(na_povezavi(10, 19, (10, 22, 10, 20))) + self.assertFalse(na_povezavi(10, 23, (10, 20, 10, 22))) + self.assertFalse(na_povezavi(10, 19, (10, 20, 10, 22))) + self.assertFalse(na_povezavi(9, 21, (10, 20, 10, 22))) + self.assertFalse(na_povezavi(9, 21, (10, 22, 10, 20))) + self.assertFalse(na_povezavi(11, 21, (10, 20, 10, 22))) + self.assertFalse(na_povezavi(11, 21, (10, 22, 10, 20))) + + self.assertTrue(na_povezavi( 20, 10, (20, 10, 22, 10))) + self.assertTrue(na_povezavi( 21, 10, (20, 10, 22, 10))) + self.assertTrue(na_povezavi( 22, 10, (20, 10, 22, 10))) + self.assertTrue(na_povezavi( 20, 10, (22, 10, 20, 10))) + self.assertTrue(na_povezavi( 21, 10, (22, 10, 20, 10))) + self.assertTrue(na_povezavi( 22, 10, (22, 10, 20, 10))) + self.assertFalse(na_povezavi(23, 10, (22, 10, 20, 10))) + self.assertFalse(na_povezavi(19, 10, (22, 10, 20, 10))) + self.assertFalse(na_povezavi(23, 10, (20, 10, 22, 10))) + self.assertFalse(na_povezavi(19, 10, (20, 10, 22, 10))) + self.assertFalse(na_povezavi(21, 9, (20, 10, 22, 10))) + self.assertFalse(na_povezavi(21, 9, (22, 10, 20, 10))) + self.assertFalse(na_povezavi(21, 11, (20, 10, 22, 10))) + self.assertFalse(na_povezavi(21, 11, (22, 10, 20, 10))) + + def test_05_povezave_tocke(self): + self.assertEqual({(3, 13, 3, 18)}, povezave_tocke(3, 15, povezave)) + self.assertEqual({(3, 13, 3, 18)}, povezave_tocke(3, 18, povezave)) + self.assertEqual({(3, 13, 3, 18)}, povezave_tocke(3, 13, povezave)) + + self.assertEqual({(11, 13, 11, 20)}, povezave_tocke(11, 17, povezave)) + self.assertEqual({(11, 13, 11, 20)}, povezave_tocke(11, 13, povezave)) + self.assertEqual({(11, 13, 11, 20)}, povezave_tocke(11, 20, povezave)) + + self.assertEqual({(6, 11, 6, 13), (2, 12, 8, 12)}, + povezave_tocke(6, 12, povezave)) + self.assertEqual({(3, 14, 7, 14), (3, 13, 3, 18)}, + povezave_tocke(3, 14, povezave)) + self.assertEqual({(13, 16, 21, 16), (13, 15, 13, 16)}, + povezave_tocke(13, 16, povezave)) + + self.assertEqual(set(), povezave_tocke(13, 17, povezave)) + + def test_06_secisce(self): + # Sekanje + self.assertEqual((10, 22), secisce((10, 20, 10, 25), (8, 22, 18, 22))) + self.assertEqual((10, 22), secisce((10, 25, 10, 22), (8, 22, 18, 22))) + self.assertEqual((10, 22), secisce((10, 25, 10, 22), (18, 22, 8, 22))) + self.assertEqual((10, 22), secisce((10, 20, 10, 25), (18, 22, 8, 22))) + + self.assertEqual((10, 22), secisce((8, 22, 18, 22), (10, 20, 10, 25))) + self.assertEqual((10, 22), secisce((8, 22, 18, 22), (10, 25, 10, 22))) + self.assertEqual((10, 22), secisce((18, 22, 8, 22), (10, 25, 10, 22))) + self.assertEqual((10, 22), secisce((18, 22, 8, 22), (10, 20, 10, 25))) + + # Dotikanje + self.assertEqual((10, 22), secisce((10, 20, 10, 25), (10, 22, 18, 22))) + self.assertEqual((10, 22), secisce((10, 25, 10, 20), (10, 22, 18, 22))) + self.assertEqual((10, 22), secisce((10, 25, 10, 20), (18, 22, 10, 22))) + self.assertEqual((10, 22), secisce((10, 20, 10, 25), (18, 22, 10, 22))) + + # Dotikanje v točki + self.assertEqual((10, 20), secisce((10, 20, 10, 25), (10, 20, 8, 20))) + self.assertEqual((10, 20), secisce((10, 25, 10, 20), (10, 20, 8, 20))) + self.assertEqual((10, 20), secisce((10, 25, 10, 20), (8, 20, 10, 20))) + self.assertEqual((10, 20), secisce((10, 20, 10, 25), (8, 20, 10, 20))) + + # Sekanje + self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 8, 22, 18))) + self.assertEqual((22, 10), secisce((25, 10, 22, 10), (22, 8, 22, 18))) + self.assertEqual((22, 10), secisce((25, 10, 22, 10), (22, 18, 22, 8))) + self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 18, 22, 8))) + self.assertEqual((22, 10), secisce((22, 8, 22, 18), (20, 10, 25, 10))) + self.assertEqual((22, 10), secisce((22, 8, 22, 18), (25, 10, 22, 10))) + self.assertEqual((22, 10), secisce((22, 18, 22, 8), (25, 10, 22, 10))) + self.assertEqual((22, 10), secisce((22, 18, 22, 8), (20, 10, 25, 10))) + + # Dotikanje + self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 10, 22, 18))) + self.assertEqual((22, 10), secisce((25, 10, 20, 10), (22, 10, 22, 18))) + self.assertEqual((22, 10), secisce((25, 10, 20, 10), (22, 18, 22, 10))) + self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 18, 22, 10))) + + # Dotikanje v točki + self.assertEqual((20, 10), secisce((20, 10, 25, 10), (20, 10, 20, 8))) + self.assertEqual((20, 10), secisce((25, 10, 20, 10), (20, 10, 20, 8))) + self.assertEqual((20, 10), secisce((25, 10, 20, 10), (20, 8, 20, 10))) + self.assertEqual((20, 10), secisce((20, 10, 25, 10), (20, 8, 20, 10))) + + # Ni sekanja: vzporedni + self.assertIsNone(secisce((10, 20, 10, 25), (8, 20, 8, 25))) + self.assertIsNone(secisce((8, 20, 8, 25), (10, 20, 10, 25))) + self.assertIsNone(secisce((8, 20, 18, 20), (1, 25, 0, 25))) + + # Ni sekanja: različni + self.assertIsNone(secisce((10, 20, 10, 25), (12, 22, 15, 22))) + + krizisca = Test07.prava_krizisca + for p1 in povezave: + for p2 in povezave: + if p1 != p2: + up1, up2 = urejena(p1), urejena(p2) + if (up1, up2) in krizisca: + self.assertEqual(krizisca[up1, up2], secisce(p1, p2), + f"Napaka v klicu secisce({p1}, {p2})") + elif (up2, up1) in krizisca: + self.assertEqual(krizisca[up2, up1], secisce(p1, p2), + f"Napaka v klicu secisce({p1}, {p2})") + else: + self.assertIsNone(secisce(p1, p2), f"Napaka v klicu secisce({p1}, {p2})") + + +class Test07(unittest.TestCase): + prava_krizisca = { + ((0, 16, 10, 16), (3, 13, 3, 18)): (3, 16), + ((0, 16, 10, 16), (9, 14, 9, 17)): (9, 16), + ((2, 12, 8, 12), (6, 11, 6, 13)): (6, 12), + ((3, 13, 3, 18), (3, 14, 7, 14)): (3, 14), + ((8, 15, 13, 15), (9, 14, 9, 17)): (9, 15), + ((8, 15, 13, 15), (11, 13, 11, 20)): (11, 15), + ((8, 15, 13, 15), (12, 14, 12, 17)): (12, 15), + ((8, 15, 13, 15), (13, 15, 13, 16)): (13, 15), + ((10, 18, 14, 18), (11, 13, 11, 20)): (11, 18), + ((10, 18, 14, 18), (14, 15, 14, 18)): (14, 18), + ((13, 15, 13, 16), (13, 16, 21, 16)): (13, 16), + ((13, 16, 21, 16), (14, 15, 14, 18)): (14, 16), + ((13, 16, 21, 16), (16, 10, 16, 16)): (16, 16), + ((13, 16, 21, 16), (17, 15, 17, 17)): (17, 16), + ((13, 16, 21, 16), (18, 14, 18, 17)): (18, 16), + ((13, 16, 21, 16), (20, 15, 20, 17)): (20, 16), + ((13, 16, 21, 16), (21, 10, 21, 19)): (21, 16), + ((15, 13, 22, 13), (16, 10, 16, 16)): (16, 13), + ((15, 13, 22, 13), (21, 10, 21, 19)): (21, 13), + ((16, 10, 16, 16), (16, 10, 21, 10)): (16, 10), + ((16, 10, 21, 10), (21, 10, 21, 19)): (21, 10), + ((19, 19, 22, 19), (21, 10, 21, 19)): (21, 19)} + + def test_01_krizisca(self): + self.assertEqual(self.prava_krizisca, krizisca(povezave)) + self.assertEqual( + {((0, 16, 10, 16), (3, 13, 3, 18)): (3, 16), + ((0, 16, 10, 16), (9, 14, 9, 17)): (9, 16), + ((2, 12, 8, 12), (6, 11, 6, 13)): (6, 12), + ((3, 13, 3, 18), (3, 14, 7, 14)): (3, 14), + ((8, 15, 13, 15), (9, 14, 9, 17)): (9, 15)}, + krizisca(povezave[:8])) + + def test_02_mozna_pot(self): + self.assertTrue(mozna_pot( + [(14, 18, 10, 18), + (14, 18, 14, 15), + (13, 16, 21, 16), + (13, 16, 13, 15), + (8, 15, 13, 15), + (9, 14, 9, 17), + (10, 16, 0, 16), + (9, 14, 9, 17), + (8, 15, 13, 15), + (13, 16, 13, 15)], self.prava_krizisca)) + + self.assertFalse(mozna_pot( + [(14, 18, 10, 18), + (14, 18, 14, 15), + (13, 16, 13, 15), + (8, 15, 13, 15), + (9, 14, 9, 17), + (10, 16, 0, 16), + (9, 14, 9, 17), + (8, 15, 13, 15), + (13, 16, 13, 15)], self.prava_krizisca)) + + self.assertFalse(mozna_pot( + [(14, 18, 10, 18), + (14, 18, 14, 15), + (13, 16, 21, 16), + (13, 16, 13, 15), + (8, 15, 14, 15), + (9, 14, 9, 17), + (10, 16, 0, 16), + (9, 14, 9, 17), + (8, 15, 13, 15), + (13, 16, 13, 15)], self.prava_krizisca)) + + def test_03_razdalja(self): + self.assertEqual( + 14, + razdalja([(14, 18, 10, 18), + (14, 18, 14, 15), + (13, 16, 21, 16), + (13, 16, 13, 15), + (8, 15, 13, 15), + (9, 14, 9, 17), + (10, 16, 0, 16), + (9, 14, 9, 17), + (8, 15, 13, 15), + (13, 16, 13, 15)], self.prava_krizisca) + ) + +class Test08(unittest.TestCase, TestOneLineMixin): + def test(self): + self.assert_is_one_line(pravilna) + self.assert_is_one_line(pravilne) + self.assert_is_one_line(urejena) + self.assert_is_one_line(povezave_tocke) + +class Test09(unittest.TestCase, TestOneLineMixin): + def test(self): + self.assert_is_one_line(krizisca) + self.assert_is_one_line(mozna_pot) + self.assert_is_one_line(razdalja) + + def test_01_svg(self): + for pov in [povezave[:8], povezave]: + urejene = set(map(urejena, pov)) + + svg(pov, "test.svg") + dom = minidom.parse("test.svg") + el_svg = dom.getElementsByTagName("svg")[0] + + viewport = el_svg.getAttribute("viewBox") + mix, miy, wi, he = map(int, viewport.split()) + self.assertLessEqual(mix, min(x for x, _, _, _ in pov)) + self.assertLessEqual(miy, min(y for _, y, _, _ in pov)) + self.assertGreaterEqual(mix + wi, max(x for _, _, x, _ in pov)) + self.assertGreaterEqual(miy + he, max(y for _, _, _, y in pov)) + + self.assertEqual( + sorted(urejene), + sorted({urejena(tuple(int(line.getAttribute(a)) for a in "x1 y1 x2 y2".split())) + for line in el_svg.getElementsByTagName("line")})) + self.assertEqual( + {p[:2] for p in pov} | {p[2:] for p in pov}, + { tuple(int(line.getAttribute(a)) for a in "cx cy".split()) + for line in el_svg.getElementsByTagName("circle")}) + + +class Test10(unittest.TestCase): + def test_01_povezane(self): + self.assertEqual( + {(0, 16, 10, 16): {(3, 13, 3, 18), + (9, 14, 9, 17)}, + (2, 12, 8, 12): {(6, 11, 6, 13)}, + (3, 13, 3, 18): {(0, 16, 10, 16), + (3, 14, 7, 14)}, + (3, 14, 7, 14): {(3, 13, 3, 18)}, + (6, 11, 6, 13): {(2, 12, 8, 12)}, + (8, 15, 13, 15): {(9, 14, 9, 17), + (11, 13, 11, 20), + (12, 14, 12, 17), + (13, 15, 13, 16)}, + (9, 14, 9, 17): {(0, 16, 10, 16), + (8, 15, 13, 15)}, + (10, 18, 14, 18): {(14, 15, 14, 18), + (11, 13, 11, 20)}, + (11, 13, 11, 20): {(8, 15, 13, 15), + (10, 18, 14, 18)}, + (12, 14, 12, 17): {(8, 15, 13, 15)}, + (13, 15, 13, 16): {(8, 15, 13, 15), + (13, 16, 21, 16)}, + (13, 16, 21, 16): {(13, 15, 13, 16), + (14, 15, 14, 18), + (16, 10, 16, 16), + (17, 15, 17, 17), + (18, 14, 18, 17), + (20, 15, 20, 17), + (21, 10, 21, 19)}, + (14, 15, 14, 18): {(10, 18, 14, 18), + (13, 16, 21, 16)}, + (15, 13, 22, 13): {(16, 10, 16, 16), + (21, 10, 21, 19)}, + (16, 10, 16, 16): {(13, 16, 21, 16), + (15, 13, 22, 13), + (16, 10, 21, 10)}, + (16, 10, 21, 10): {(16, 10, 16, 16), + (21, 10, 21, 19)}, + (17, 15, 17, 17): {(13, 16, 21, 16)}, + (18, 14, 18, 17): {(13, 16, 21, 16)}, + (19, 19, 22, 19): {(21, 10, 21, 19)}, + (20, 15, 20, 17): {(13, 16, 21, 16)}, + (21, 10, 21, 19): {(13, 16, 21, 16), + (15, 13, 22, 13), + (16, 10, 21, 10), + (19, 19, 22, 19)}}, + povezane(Test07.prava_krizisca)) + + def test_02_dostopne(self): + obmocje1 = { + (0, 16, 10, 16), + (3, 13, 3, 18), + (3, 14, 7, 14), + (8, 15, 13, 15), + (9, 14, 9, 17), + (10, 18, 14, 18), + (11, 13, 11, 20), + (12, 14, 12, 17), + (13, 15, 13, 16), + (13, 16, 21, 16), + (14, 15, 14, 18), + (15, 13, 22, 13), + (16, 10, 16, 16), + (16, 10, 21, 10), + (17, 15, 17, 17), + (18, 14, 18, 17), + (19, 19, 22, 19), + (20, 15, 20, 17), + (21, 10, 21, 19)} + + obmocje2 = {(6, 11, 6, 13), (2, 12, 8, 12)} + obmocje3 = {(11, 10, 13, 10)} + + self.assertEqual(obmocje1, dostopne((0, 16, 10, 16), Test07.prava_krizisca)) + self.assertEqual(obmocje1, dostopne((20, 15, 20, 17), Test07.prava_krizisca)) + self.assertEqual(obmocje1, dostopne((20, 17, 20, 15), Test07.prava_krizisca)) + + self.assertEqual(obmocje2, dostopne((2, 12, 8, 12), Test07.prava_krizisca)) + self.assertEqual(obmocje2, dostopne((8, 12, 2, 12), Test07.prava_krizisca)) + self.assertEqual(obmocje2, dostopne((6, 13, 6, 11), Test07.prava_krizisca)) + self.assertEqual(obmocje2, dostopne((6, 11, 6, 13), Test07.prava_krizisca)) + + self.assertEqual(obmocje3, dostopne((11, 10, 13, 10), Test07.prava_krizisca)) + self.assertEqual(obmocje3, dostopne((13, 10, 11, 10), Test07.prava_krizisca)) + + def test_03_pot(self): + for sx, sy, ex, ey in [(11, 19, 17, 10), + (17, 10, 11, 19), + (1, 16, 22, 13)]: + najdena = pot(sx, sy, ex, ey, Test07.prava_krizisca) + rez = '\n'.join(map(str, najdena)) + napaka = f"Napaka pri iskanju poti od ({sx}, {sy}) do ({ex}, {ey}):\n{rez}" + self.assertTrue(mozna_pot(najdena, Test07.prava_krizisca), napaka) + self.assertTrue(na_povezavi(sx, sy, najdena[0]), napaka) + self.assertTrue(na_povezavi(ex, ey, najdena[-1]), napaka) + + # Ni poti - območji sta nepovezani + self.assertIsNone(pot(11, 19, 13, 10, Test07.prava_krizisca)) + + # Na prvi točki ni povezave + self.assertIsNone(pot(8, 18, 8, 16, Test07.prava_krizisca)) + # Na drugi točki ni povezave + self.assertIsNone(pot(8, 16, 8, 18, Test07.prava_krizisca)) + + +if __name__ == "__main__": + unittest.main()