import random
import io
import collections
import unittest
class TestNajpogostejse(unittest.TestCase):
    def test_najpogostejse(self):
        self.assertEqual(najpogostejse('a'), ('a', 'a'))
        self.assertEqual(najpogostejse('aa bb aa'), ('aa', 'a'))
        self.assertEqual(najpogostejse('in to in ono in to smo mi'), ('in', ' '))
        self.assertEqual(najpogostejse('abc abc abc abacbca'), ('abc', 'a'))
        self.assertEqual(najpogostejse('abc abc abc abacbcb'), ('abc', 'b'))
        self.assertEqual(najpogostejse('abc abc abc abacbcc'), ('abc', 'c'))

    def test_najpogostejse_urejene(self):
        self.assertEqual(najpogostejse_urejene('a'), (['a'], ['a']))
        self.assertEqual(najpogostejse_urejene('aa bb aa'), (['aa', 'bb'], ['a', ' ', 'b']))
        self.assertEqual(najpogostejse_urejene('in to in ono in to smo mi'),
            (['in', 'to', 'mi', 'ono', 'smo'], [' ', 'o', 'i', 'n', 'm', 't', 's']))
        self.assertEqual(najpogostejse_urejene('abc abc abc abacbca'),
            (['abc', 'abacbca'], ['a', 'b', 'c', ' ']))
        self.assertEqual(najpogostejse_urejene('abc abc abc abacbcb'),
            (['abc', 'abacbcb'], ['b', 'a', 'c', ' ']))
        self.assertEqual(najpogostejse_urejene('abc abc abc abacbcc'),
            (['abc', 'abacbcc'], ['c', 'a', 'b', ' ']))

class TestTransakcije(unittest.TestCase):
    def test_transakcije(self):
        self.assertEqual(transakcije([("Ana", 0), ("Berta", 1)],
                                     [("Berta", "Ana", 1)]), "Ana")

        self.assertEqual(transakcije([("Ana", 0), ("Berta", 1)],
                                     []), "Berta")

        self.assertEqual(transakcije([("Ana", 3), ("Berta", 2)],
                                     [("Berta", "Berta", 3)]), "Ana")

        self.assertEqual(transakcije(
            [("Ana", 4), ("Berta", 8), ("Cilka", 10)],
            [("Cilka", "Ana", 3), ("Cilka", "Ana", 2), ("Ana", "Berta", 2)]
        ), "Berta")

        from random import choice
        ime = "".join(choice("abcdefghijklmnopqrstuvwxyz") for i in range(10))
        self.assertEqual(transakcije([(ime, 0), ("Cilka", 1)],
                                     [("Cilka", ime, 1)]), ime)        

class TestDruzinsko(unittest.TestCase):
    def setUp(self):
        self.tree = {
            'alice': ['mary', 'tom', 'judy'],
            'bob': ['mary', 'tom', 'judy'],
            'ken': ['suzan'],
            'renee': ['rob', 'bob'],
            'rob': ['jim'],
            'sid': ['rob', 'bob'],
            'tom': ['ken']}
    
    def assertDictCounterEqual(self, first, second, msg=None):
        def dict_counter(d):
            d_copy = dict(d)
            for k, v in d_copy.items():
                d_copy[k] = collections.Counter(v)
            return d_copy
        self.assertDictEqual(dict_counter(first), dict_counter(second), msg)

    def test_family_tree(self):
        family = io.StringIO('''
bob mary
bob tom
bob judy
alice mary
alice tom
alice judy
renee rob
renee bob
sid rob
sid bob
tom ken
ken suzan
rob jim'''.strip())
        
        self.assertDictCounterEqual(family_tree(family), self.tree)

    def test_children(self):
        self.assertCountEqual(children(self.tree, 'alice'), ['mary', 'tom', 'judy'])
        self.assertCountEqual(children(self.tree, 'mary'), [])
        self.assertCountEqual(children(self.tree, 'renee'), ['bob', 'rob'])
        self.assertCountEqual(children(self.tree, 'rob'), ['jim'])
        self.assertCountEqual(children(self.tree, 'suzan'), [])

    def test_grandchildren(self):
        self.assertCountEqual(grandchildren(self.tree, 'alice'), ['ken'])
        self.assertCountEqual(grandchildren(self.tree, 'bob'), ['ken'])
        self.assertCountEqual(grandchildren(self.tree, 'ken'), [])
        self.assertCountEqual(grandchildren(self.tree, 'mary'), [])
        self.assertCountEqual(grandchildren(self.tree, 'renee'), ['jim', 'mary', 'tom', 'judy'])
        self.assertCountEqual(grandchildren(self.tree, 'sid'), ['jim', 'mary', 'tom', 'judy'])
        self.assertCountEqual(grandchildren(self.tree, 'tom'), ['suzan'])

    def test_successors(self):
        self.assertCountEqual(successors(self.tree, 'tom'), ['ken', 'suzan'])
        self.assertCountEqual(successors(self.tree, 'sid'),
            ['rob', 'bob', 'jim', 'mary', 'tom', 'judy', 'ken', 'suzan'])
        self.assertCountEqual(successors(self.tree, 'suzan'), [])
        self.assertCountEqual(successors(self.tree, 'ken'), ['suzan'])
        self.assertCountEqual(successors(self.tree, 'rob'), ['jim'])


class TestNatakar(unittest.TestCase):
    def test_narocila_brez_preklicev(self):
        self.assertDictEqual(narocila(
            [("Tone", "pivo")]),
            {"Tone": ["pivo"]})

        self.assertDictEqual(narocila(
            [("Tone", "pizza"), ("Tone", "sok")]),
            {"Tone": ["pizza", "sok"]})

        # Poskusi nakljucno generirano ime in jed!
        from random import choice
        ime = "".join(choice("abcdefghijklmnopqrstuvwxyz") for i in range(10))
        jed = "".join(choice("abcdefghijklmnopqrstuvwxyz") for i in range(10))
        self.assertDictEqual(narocila([(ime, jed)]), {ime: [jed]})

    def test_narocila(self):
        self.assertDictEqual(narocila(
            [('Ana', 'torta'), ('Berta', 'krof'), ('Cilka', 'kava'),
             ('Ana', 'kava'), ('Berta', '-krof'), ('Cilka', '-torta'),
             ('Berta', 'torta')]),
            {'Cilka': ['kava'], 'Berta': ['torta'], 'Ana': ['torta', 'kava']})

        self.assertDictEqual(narocila([('Ana', 'torta'), ('Ana', '-torta')]),
            {'Ana': []})

        r = narocila([('Ana', '-torta')])
        self.assertTrue(r == {} or r == {'Ana': []})

class TestNakljucno(unittest.TestCase):
    def assertDictCounterEqual(self, first, second, msg=None):
        def dict_counter(d):
            d_copy = dict(d)
            for k, v in d_copy.items():
                d_copy[k] = collections.Counter(v)
            return d_copy
        self.assertDictEqual(dict_counter(first), dict_counter(second), msg)

    def test_nasledniki(self):
        self.assertDictCounterEqual(nasledniki('in in in in'), {'in': ['in', 'in', 'in']})
        self.assertDictCounterEqual(nasledniki('in to in ono in to smo mi'),
            {'smo': ['mi'], 'to': ['in', 'smo'], 'ono': ['in'], 'in': ['to', 'ono', 'to']})
        self.assertDictCounterEqual(nasledniki('danes je lep dan danes sije sonce'),
            {'lep': ['dan'], 'je': ['lep'], 'dan': ['danes'], 'danes': ['je', 'sije'], 'sije': ['sonce']})

    def test_tekst(self):
        self.assertEqual(tekst({'in': ['in', 'in']}, 3), 'in in in')


if __name__ == '__main__':
    unittest.main(verbosity=2)