from math import sin, cos, sqrt, pi

class Robot:
    def __init__(self):
        self.x = self.y = 0
        self.pot = [(0, 0)]

    def premik(self, kot, koliko):
        self.x += koliko * cos(kot)
        self.y += koliko * sin(kot)
        self.pot.append((self.x, self.y))


import unittest
class TestIzpit150609(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.maxDiff = None

    def test_01_prelivanje(self):
        velikosti = [5, 7, 4]
        vsebine = [3, 4, 1]
        pretoci(velikosti, vsebine, 1, 0)
        self.assertEqual(vsebine, [5, 2, 1])
        pretoci(velikosti, vsebine, 2, 1)
        self.assertEqual(vsebine, [5, 3, 0])
        pretoci(velikosti, vsebine, None, 2)
        self.assertEqual(vsebine, [5, 3, 4])
        pretoci(velikosti, vsebine, 1, None)
        self.assertEqual(vsebine, [5, 0, 4])
        pretoci(velikosti, vsebine, 0, 1)
        self.assertEqual(vsebine, [0, 5, 4])
        pretoci(velikosti, vsebine, None, 0)
        self.assertEqual(vsebine, [5, 5, 4])
        pretoci(velikosti, vsebine, 1, 0)
        self.assertEqual(vsebine, [5, 5, 4])

        velikosti = [1] * 100
        vsebine = [0] * 100
        pretoci(velikosti, vsebine, None, 99)
        self.assertEqual(vsebine, [0] * 99 + [1])
        pretoci(velikosti, vsebine, 99, 98)
        self.assertEqual(vsebine, [0] * 98 + [1, 0])
        pretoci(velikosti, vsebine, 98, None)
        self.assertEqual(vsebine, [0] * 100)

    def test_02_colni(self):
        self.assertTrue(ni_preobremenjenih([[1, 1], [2, 5], [1, 6, 8]], 16))
        self.assertTrue(ni_preobremenjenih([[1, 1], [2, 5], [1, 6, 8]], 15))
        self.assertFalse(ni_preobremenjenih([[1, 1], [2, 5], [1, 6, 8]], 14))
        self.assertFalse(ni_preobremenjenih([[1, 1], [1, 6, 8], [2, 5]], 14))
        self.assertFalse(ni_preobremenjenih([[1, 6, 8], [1, 1], [2, 5]], 14))

        self.assertTrue(ni_preobremenjenih([[1]], 1))
        self.assertTrue(ni_preobremenjenih([[1]], 2))
        self.assertFalse(ni_preobremenjenih([[1]], 0))

    def test_03_pari(self):
        try:
            print(vecji([1] * 2000, [0] * 2000))
        except RuntimeError:
            pass
        else:
            self.fail("Funkcija mora biti rekurzivna")

        self.assertTrue(vecji([185, 180, 183], [182, 179, 180]))
        self.assertTrue(vecji([185, 180, 183, 1, 1, 1, 1],
                              [182, 179, 180, 0, 0, 0, 0]))

        self.assertFalse(vecji([185, 180, 179], [182, 177, 180]))
        self.assertFalse(vecji([185, 176, 183], [182, 177, 180]))
        self.assertFalse(vecji([181, 176, 183], [182, 177, 180]))
        self.assertFalse(vecji([185, 180, 183, 1, 1, 1, 1],
                              [182, 179, 180, 0, 0, 2, 0]))
        self.assertFalse(vecji([185, 180, 183, 1, 1, 1, 1],
                              [182, 179, 180, 0, 0, 0, 2]))

        self.assertTrue(vecji([183, 177], [182, 172]))
        self.assertTrue(vecji([183], [182]))

        self.assertFalse(vecji([181], [182]))
        self.assertFalse(vecji([183, 184], [182, 185]))

    def test_04_podobnosti(self):
        besedila = ["A B C", "A B D", "D E F", "F G"]
        self.assertEqual(podobnosti(besedila),
            {("A B C", "A B D"): 2 / 4,   ("A B D", "A B C"): 2 / 4,
             ("A B C", "D E F"): 0,       ("D E F", "A B C"): 0,
             ("A B C", "F G"): 0,         ("F G", "A B C"): 0,
             ("A B D", "D E F"): 1 / 5,   ("D E F", "A B D"): 1 / 5,
             ("A B D", "F G"): 0,         ("F G", "A B D"): 0,
             ("D E F", "F G"): 1 / 4,     ("F G", "D E F"): 1 / 4,
             })

        besedila = ["A B", "A B D"]
        self.assertEqual(podobnosti(besedila),
                         {("A B", "A B D"): 2 / 3, ("A B D", "A B"): 2 / 3})

        besedila = ["A B", "B A"]
        self.assertEqual(podobnosti(besedila),
                         {("A B", "B A"): 1, ("B A", "A B"): 1})

    def test_05_dolzina_poti(self):
        r = Robot()
        self.assertAlmostEqual(r.dolzina_poti(), 0)
        r.premik(0.2, 40)
        self.assertAlmostEqual(r.dolzina_poti(), 40)
        r.premik(-0.1, 30)
        self.assertAlmostEqual(r.dolzina_poti(), 70)
        r.premik(0.1, -20)
        self.assertAlmostEqual(r.dolzina_poti(), 90)

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