コード例 #1
0
    def setUp(self):
        node_ids = [
            1, 2, 5, 10, 20, 41, 21, 11, 22, 44, 89, 45, 91, 182, 364, 729,
            1459
        ]

        init = [(node_id, "{0}".format(node_id)) for node_id in node_ids]
        self.tree = BinaryTree(init)
コード例 #2
0
ファイル: dict.py プロジェクト: KrestMoraes/libforensics
    def setUp(self):
        node_ids = [
            1, 2, 5, 10, 20, 41, 21, 11, 22, 44, 89, 45, 91, 182, 364, 729,
            1459
        ]

        init = [(node_id, "{0}".format(node_id)) for node_id in node_ids]
        self.tree = BinaryTree(init)
コード例 #3
0
ファイル: dict.py プロジェクト: KrestMoraes/libforensics
class BinaryTreeTestCase(TestCase):
    def setUp(self):
        node_ids = [
            1, 2, 5, 10, 20, 41, 21, 11, 22, 44, 89, 45, 91, 182, 364, 729,
            1459
        ]

        init = [(node_id, "{0}".format(node_id)) for node_id in node_ids]
        self.tree = BinaryTree(init)
    # end def setUp

    def test__init__(self):
        ar = self.assertRaises

        ar(TypeError, BinaryTree, [("1", 1)])
        ar(TypeError, BinaryTree, [(-1, 1)])
        ar(TypeError, BinaryTree, [(0, 1)])
    # end def test__init__

    def test__setitem__(self):
        ar = self.assertRaises

        ar(TypeError, BinaryTree.__setitem__, "1", 1)
        ar(TypeError, BinaryTree.__setitem__, -1, 1)
        ar(TypeError, BinaryTree.__setitem__, 0, 1)
    # end def test__setitem__

    def test_is_internal(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: True,
            2: True,
            5: True,
            10: True,
            20: True,
            41: False,
            21: False,
            11: True,
            22: True,
            44: True,
            89: False,
            45: True,
            91: True,
            182: True,
            364: True,
            729: True,
            1459: False
        }

        for key, value in results.items():
            ae(self.tree.is_internal(key), value)
        # end for

        ar(TypeError, self.tree.is_internal, "1")
    # end def test_is_internal

    def test_is_external(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: False,
            2: False,
            5: False,
            10: False,
            20: False,
            41: True,
            21: True,
            11: False,
            22: False,
            44: False,
            89: True,
            45: False,
            91: False,
            182: False,
            364: False,
            729: False,
            1459: True
        }

        for key, value in results.items():
            ae(self.tree.is_external(key), value)
        # end for

        ar(TypeError, self.tree.is_external, "1")
    # end def test_is_external

    def test_get_left_child_id(self):
        ae = self.assertEqual
        ar = self.assertRaises

        for key in self.tree:
            ae(self.tree.get_left_child_id(key), key * 2)
        # end for

        ar(TypeError, self.tree.get_left_child_id, "1")
    # end def test_get_left_child_id

    def test_has_left_child(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: True,
            2: False,
            5: True,
            10: True,
            20: False,
            41: False,
            21: False,
            11: True,
            22: True,
            44: False,
            89: False,
            45: False,
            91: True,
            182: True,
            364: False,
            729: False,
            1459: False
        }

        for key, value in results.items():
            ae(self.tree.has_left_child(key), value)
        # end for

        ar(TypeError, self.tree.has_left_child, "1")
    # end def test_has_left_child

    def test_get_right_child_id(self):
        ae = self.assertEqual
        ar = self.assertRaises

        for key in self.tree:
            ae(self.tree.get_right_child_id(key), (key * 2) + 1)
        # end for

        ar(TypeError, self.tree.get_right_child_id, "1")
        ar(TypeError, self.tree.get_right_child_id, -1)
        ar(TypeError, self.tree.get_right_child_id, 0)
    # end def test_get_right_child_id

    def test_has_right_child(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: False,
            2: True,
            5: True,
            10: True,
            20: True,
            41: False,
            21: False,
            11: False,
            22: True,
            44: True,
            89: False,
            45: True,
            91: False,
            182: False,
            364: True,
            729: True,
            1459: False
        }

        for key, value in results.items():
            ae(self.tree.has_right_child(key), value)
        # end for

        ar(TypeError, self.tree.has_right_child, "1")
コード例 #4
0
class BinaryTreeTestCase(TestCase):
    def setUp(self):
        node_ids = [
            1, 2, 5, 10, 20, 41, 21, 11, 22, 44, 89, 45, 91, 182, 364, 729,
            1459
        ]

        init = [(node_id, "{0}".format(node_id)) for node_id in node_ids]
        self.tree = BinaryTree(init)

    # end def setUp

    def test__init__(self):
        ar = self.assertRaises

        ar(TypeError, BinaryTree, [("1", 1)])
        ar(TypeError, BinaryTree, [(-1, 1)])
        ar(TypeError, BinaryTree, [(0, 1)])

    # end def test__init__

    def test__setitem__(self):
        ar = self.assertRaises

        ar(TypeError, BinaryTree.__setitem__, "1", 1)
        ar(TypeError, BinaryTree.__setitem__, -1, 1)
        ar(TypeError, BinaryTree.__setitem__, 0, 1)

    # end def test__setitem__

    def test_is_internal(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: True,
            2: True,
            5: True,
            10: True,
            20: True,
            41: False,
            21: False,
            11: True,
            22: True,
            44: True,
            89: False,
            45: True,
            91: True,
            182: True,
            364: True,
            729: True,
            1459: False
        }

        for key, value in results.items():
            ae(self.tree.is_internal(key), value)
        # end for

        ar(TypeError, self.tree.is_internal, "1")

    # end def test_is_internal

    def test_is_external(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: False,
            2: False,
            5: False,
            10: False,
            20: False,
            41: True,
            21: True,
            11: False,
            22: False,
            44: False,
            89: True,
            45: False,
            91: False,
            182: False,
            364: False,
            729: False,
            1459: True
        }

        for key, value in results.items():
            ae(self.tree.is_external(key), value)
        # end for

        ar(TypeError, self.tree.is_external, "1")

    # end def test_is_external

    def test_get_left_child_id(self):
        ae = self.assertEqual
        ar = self.assertRaises

        for key in self.tree:
            ae(self.tree.get_left_child_id(key), key * 2)
        # end for

        ar(TypeError, self.tree.get_left_child_id, "1")

    # end def test_get_left_child_id

    def test_has_left_child(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: True,
            2: False,
            5: True,
            10: True,
            20: False,
            41: False,
            21: False,
            11: True,
            22: True,
            44: False,
            89: False,
            45: False,
            91: True,
            182: True,
            364: False,
            729: False,
            1459: False
        }

        for key, value in results.items():
            ae(self.tree.has_left_child(key), value)
        # end for

        ar(TypeError, self.tree.has_left_child, "1")

    # end def test_has_left_child

    def test_get_right_child_id(self):
        ae = self.assertEqual
        ar = self.assertRaises

        for key in self.tree:
            ae(self.tree.get_right_child_id(key), (key * 2) + 1)
        # end for

        ar(TypeError, self.tree.get_right_child_id, "1")
        ar(TypeError, self.tree.get_right_child_id, -1)
        ar(TypeError, self.tree.get_right_child_id, 0)

    # end def test_get_right_child_id

    def test_has_right_child(self):
        ae = self.assertEqual
        ar = self.assertRaises

        results = {
            1: False,
            2: True,
            5: True,
            10: True,
            20: True,
            41: False,
            21: False,
            11: False,
            22: True,
            44: True,
            89: False,
            45: True,
            91: False,
            182: False,
            364: True,
            729: True,
            1459: False
        }

        for key, value in results.items():
            ae(self.tree.has_right_child(key), value)
        # end for

        ar(TypeError, self.tree.has_right_child, "1")