import unittest
class Test_1(unittest.TestCase):
    def test_se_sekata(self):
        self.assertTrue(se_sekata(0, 0, 1, 0, 0, 1))
        self.assertTrue(se_sekata(0, 0, 1, 0, 0, 2))
        self.assertTrue(se_sekata(0, 1, 1, 1, 0, 2))
        self.assertTrue(se_sekata(5, 2, 1, 7, 2, 1))
        self.assertTrue(se_sekata(5, 2, 1, 7, 2, 2))
        self.assertTrue(se_sekata(2, 5, 1, 2, 7, 1))
        self.assertTrue(se_sekata(2, 5, 1, 2, 7, 2))
        self.assertTrue(se_sekata(10, 40, 5, 20, 30, 10))

        self.assertFalse(se_sekata(0, 0, 1, 5, 0, 1))
        self.assertFalse(se_sekata(0, 0, 1, 0, -4, 2))
        self.assertFalse(se_sekata(0, 1, 1, 1, 0, 0.1))
        self.assertFalse(se_sekata(5, 2, 1, 7, 2, 0.5))
        self.assertFalse(se_sekata(5, 2, 0.5, 7, 2, 1))
        self.assertFalse(se_sekata(2, 5, 1, 2, 7, 0.5))
        self.assertFalse(se_sekata(2, 5, 0.5, 2, 7, 1))
        self.assertFalse(se_sekata(10, 40, 5, 20, 30, 8))

    def test_seka_koga(self):
        self.assertTrue(seka_koga(5, 3, 2, [(5, 3, 2)]))
        self.assertTrue(seka_koga(5, 3, 1, [(6, 4, 0.5)]))
        self.assertTrue(seka_koga(5, 3, 1, [(6, 4, 0.5), (1, 1, 1)]))
        self.assertTrue(seka_koga(5, 3, 1, [(1, 1, 1), (6, 4, 0.5), (1, 1, 1)]))
        self.assertTrue(seka_koga(5, 3, 1, [(1, 1, 1), (6, 4, 0.5)]))

        self.assertFalse(seka_koga(5, 3, 2, []))
        self.assertFalse(seka_koga(5, 3, 2, [(1, 1, 1)]))
        self.assertFalse(seka_koga(5, 3, 2, [(1, 1, 1), (-5, 2, 1)]))

    def test_krogi(self):
        n, p = krogi([(1, 1, 1)])
        self.assertEqual(n, 1)
        self.assertAlmostEqual(p, pi)

        n, p = krogi([])
        self.assertEqual(n, 0)
        self.assertAlmostEqual(p, 0)

        n, p = krogi([(1, 1, 1), (2, 1, 1.5)])
        self.assertEqual(n, 1)
        self.assertAlmostEqual(p, pi)

        n, p = krogi([(2, 1, 1.5), (1, 1, 1)])
        self.assertEqual(n, 1)
        self.assertAlmostEqual(p, pi * 1.5 ** 2)

        n, p = krogi([(1, 1, 1), (2, 1, 1.5), (1, 1, 1)])
        self.assertEqual(n, 1)
        self.assertAlmostEqual(p, pi)

        n, p = krogi([(1, 1, 1), (3.5, 0, 0.5)])
        self.assertEqual(n, 2)
        self.assertAlmostEqual(p, pi * (1 + .5 ** 2))

        n, p = krogi([(1, 1, 1), (3.5, 0, 0.5), (0, 2, 1.2)])
        self.assertEqual(n, 2)
        self.assertAlmostEqual(p, pi * (1 + .5 ** 2))

        n, p = krogi([(1, 1, 1), (3.5, 0, 0.5), (0, 2, 1.2), (-2, -2, 1.5)])
        self.assertEqual(n, 3)
        self.assertAlmostEqual(p, pi * (1 + .5 ** 2 + 1.5 ** 2))

        n, p = krogi([(1, 1, 1), (3.5, 0, 0.5), (0, 2, 1.2), (-2, -2, 1.5),
                      (1, 1, 1)])
        self.assertEqual(n, 3)
        self.assertAlmostEqual(p, pi * (1 + .5 ** 2 + 1.5 ** 2))

        n, p = krogi([(1, 1, 1), (3.5, 0, 0.5), (0, 2, 1.2), (-2, -2, 1.5),
                      (1, 1, 1), (0, 0, 0.1)])
        self.assertEqual(n, 4)
        self.assertAlmostEqual(p, pi * (1 + .5 ** 2 + 1.5 ** 2 + .1 ** 2))

        n, p = krogi([(1, 1, 1), (3.5, 0, 0.5), (0, 2, 1.2), (-2, -2, 1.5),
                      (1, 1, 1), (0, 0, 0.1), (0, -2, 0.6)])
        self.assertEqual(n, 4)
        self.assertAlmostEqual(p, pi * (1 + .5 ** 2 + 1.5 ** 2 + .1 ** 2))


class Test_2(unittest.TestCase):
    def test_narascajoci(self):
        try:
            narascajoci(list(range(1000)))
            self.fail("Nalogo je potrebno rešiti z rekurzivno funkcijo!!!")
        except RuntimeError:
            pass

        self.assertTrue(narascajoci([]))
        self.assertTrue(narascajoci([12]))
        self.assertTrue(narascajoci([12, 18]))
        self.assertTrue(narascajoci([12, 18, 26]))
        self.assertTrue(narascajoci([12, 18, 26, 33]))

        self.assertFalse(narascajoci([18, 12]))
        self.assertFalse(narascajoci([5, 18, 12]))
        self.assertFalse(narascajoci([5, 6, 18, 12]))
        self.assertFalse(narascajoci([18, 12, 13]))
        self.assertFalse(narascajoci([18, 12, 13, 15]))
        self.assertFalse(narascajoci([5, 6, 18, 12, 13, 14]))


class Test_3(unittest.TestCase):
    def test_prijatelji(self):
        sociogram = {"Ana": {"Berta"}, "Berta": {"Ana", "Cilka", "Ema"},
                     "Cilka": set(), "Dani": {"Berta"}, "Ema": {"Ana", "Berta"},
                     "Fanči": {"Cilka", "Dani"}}
        self.assertEqual(prijatelji("Ema", sociogram), {"Berta"})
        self.assertEqual(prijatelji("Dani", sociogram), {"Fanči"})
        self.assertEqual(prijatelji("Cilka", sociogram), {"Berta", "Fanči"})
        self.assertEqual(prijatelji("Berta", sociogram), {"Ema", "Dani", "Ana"})
        self.assertEqual(prijatelji("Fanči", sociogram), set())

    def test_najbolj_priljubljen(self):
        sociogram = {"Ana": {"Berta"}, "Berta": {"Ana", "Cilka", "Ema"},
                     "Cilka": set(), "Dani": {"Berta"}, "Ema": {"Ana", "Berta"},
                     "Fanči": {"Cilka", "Dani"}}
        self.assertEqual(najbolj_priljubljen(sociogram), "Berta")


class Test_4(unittest.TestCase):
    def test_ploscina(self):
        from math import pi
        krog = Krog(0, 2, 3)
        self.assertAlmostEqual(krog.ploscina(), 9 * pi)

        krog = Krog(0, 2, 1)
        self.assertAlmostEqual(krog.ploscina(), pi)

    def test_se_sekata(self):
        self.assertTrue(Krog(0, 0, 1).seka(Krog(0, 0, 1)))
        self.assertTrue(Krog(0, 0, 1).seka(Krog(0, 0, 2)))
        self.assertTrue(Krog(0, 1, 1).seka(Krog(1, 0, 2)))
        self.assertTrue(Krog(5, 2, 1).seka(Krog(5, 2, 1)))
        self.assertTrue(Krog(5, 2, 1).seka(Krog(7, 2, 2)))
        self.assertTrue(Krog(2, 5, 1).seka(Krog(2, 7, 1)))
        self.assertTrue(Krog(10, 40, 5).seka(Krog(20, 30, 10)))

        self.assertFalse(Krog(0, 0, 1).seka(Krog(5, 0, 1)))
        self.assertFalse(Krog(0, 0, 1).seka(Krog(0, -4, 2)))
        self.assertFalse(Krog(0, 1, 1).seka(Krog(1, 0, 0.1)))


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