Пример #1
0
class Test_Empty_SplayTree(unittest.TestCase):
    """ A class Test empty SplayTree.
    """
    
    def setUp(self):
        ''' Setup test case each time. 
        '''
        self.test1 = SplayTree()
    
    def tearDown(self):
        ''' Reset test case to default
        '''
        self.test1 = None
    
    def test_emptptree_search(self):
        ''' test search in an empty tree.
        '''
        self.assertFalse(self.test1.search(2), "check search in empty tree")
        
    def test_emptyllist_max(self):
        ''' test max method in empty tree.
        '''        
        self.assertRaises(EmptyException, self.test1.max)
    
    def test_emptyllist_min(self):
        ''' test min method in empty tree.
        '''
        self.assertRaises(EmptyException, self.test1.min)
    
    def test_emptyllist_traverse(self):
        ''' test traverse method in empty tree.
        '''
        self.assertEqual(self.test1.traverse(), [], "traverse in empty tree")
    
    def test_emptyllist_remove(self):
        ''' test remove method in empty tree, raise EmptyException.
        '''
        self.assertRaises(EmptyException, self.test1.remove, 2)
        
    def test_emptyllist_insert(self):
        ''' test insert method in empty tree.
        '''
        self.test1.insert(5)
        self.assertEqual(self.test1.traverse(), [5], "insert in empty tree")
        
    def test_emptyllist_insert_2(self):
        ''' test insert an uncompare data in empty tree, 
            raise UnCompareExeption
        '''
        self.assertRaises(UnCompareExeption, self.test1.insert, {1:2})    
Пример #2
0
class Test_OneElement_SplayTree(unittest.TestCase):
    """ A class Test OneElement SplayTree.
    """
    
    def setUp(self):
        ''' Setup test case each time. 
        '''
        self.test1 = SplayTree([5])
    
    def tearDown(self):
        ''' Reset test case to default
        '''
        self.test1 = None
    
    def test_search(self):
        ''' test search in tree.
        '''
        self.assertFalse(self.test1.search(2), "check search in tree")
        self.assertTrue(self.test1.search(5), "check search in tree")
        
    def test_max(self):
        ''' test max method in tree.
        '''        
        self.assertEqual(self.test1.max(), 5, "max method in tree")
    
    def test_min(self):
        ''' test min method in tree.
        '''
        self.assertEqual(self.test1.min(), 5, "min method in tree")
    
    def test_traverse(self):
        ''' test traverse method in tree.
        '''
        self.assertEqual(self.test1.traverse(), [5], "traverse in tree")
    
    def test_remove_1(self):
        ''' test remove an element not in tree, does nothing.
        '''
        self.test1.remove(2)
        self.assertEqual(self.test1.traverse(), [5], "traverse in tree")
        
    def test_remove_2(self):
        ''' test remove an element in tree.
        '''
        self.test1.remove(5)
        self.assertEqual(self.test1.traverse(), [], "traverse in tree")
        
    def test_remove_3(self):
        ''' test remove an uncomareable element in tree, raise UncompareExption.
        '''
        self.assertRaises(UnCompareExeption, self.test1.remove, 'a')
    
    def test_insert(self):
        ''' test insert duplicate element in tree.
        '''
        self.test1.insert(5)
        self.assertEqual(self.test1.traverse(), [5,5], "insert in tree")
    
    def test_insert_2(self):
        ''' test insert different element in tree and splay to the root.
        '''
        self.test1.insert(7)
        self.assertEqual(self.test1.traverse(), [5,7], "insert in tree")
        self.assertEqual(self.test1.root.data, 7, "insert in tree")
                
    def test_insert_3(self):
        ''' test insert uncompareable element in tree.
        '''
        self.assertRaises(UnCompareExeption, self.test1.insert, 'a')
Пример #3
0
class Test_Multielement_Str_SplayTree(unittest.TestCase):
    """ A class Test Multielement SplayTree.
    """
    
    def setUp(self):
        ''' Setup test case each time. 
        '''
        self.test1 = SplayTree(['c', 'z', 'b', 'a', 'd', 's'])
    
    def tearDown(self):
        ''' Reset test case to default
        '''
        self.test1 = None
    
    def test_search(self):
        ''' test search in tree.
        '''
        self.assertFalse(self.test1.search(2), "check search in tree")
        self.assertTrue(self.test1.search('a'), "check search in tree")
        self.assertEqual(self.test1.root.data, 'a', "insert in tree")
        
    def test_max(self):
        ''' test max method in tree.
        '''        
        self.assertEqual(self.test1.max(), 'z', "max method in tree")
        self.assertEqual(self.test1.root.data, 'z', "insert in tree")
    
    def test_min(self):
        ''' test min method in tree.
        '''
        self.assertEqual(self.test1.min(), 'a', "min method in tree")
        self.assertEqual(self.test1.root.data, 'a', "insert in tree")
    
    def test_traverse(self):
        ''' test traverse method in tree.
        '''
        self.assertEqual(self.test1.traverse(), ['a', 'b', 'c', 'd', 's', 'z']\
                         , "traverse in tree")
    
    def test_remove_1(self):
        ''' test remove an uncomareable element in tree, raise UncompareExption.
        '''
        self.assertRaises(UnCompareExeption, self.test1.remove, 2)
        
    def test_remove_2(self):
        ''' test remove an element in tree.
        '''
        self.test1.remove('s')
        self.assertEqual(self.test1.traverse(), ['a', 'b', 'c', 'd', 'z']\
                         , "traverse in tree")
        self.assertEqual(self.test1.root.data, 'z', "insert in tree")
        
    def test_insert(self):
        ''' test insert duplicate element in tree.
        '''
        self.test1.insert('c')
        self.assertEqual(self.test1.traverse(), \
                         ['a', 'b', 'c', 'c', 'd', 's', 'z']\
                         , "traverse in tree")
        self.assertEqual(self.test1.root.data, 'c', "insert in tree")
    
    def test_insert_2(self):
        ''' test insert different element in tree and splay to the root.
        '''
        self.test1.insert('m')
        self.assertEqual(self.test1.traverse(),\
                         ['a', 'b', 'c', 'd', 'm', 's', 'z']\
                         , "traverse in tree")
        self.assertEqual(self.test1.root.data, 'm', "insert in tree")
                
    def test_insert_3(self):
        ''' test insert uncompareable element in tree.
        '''
        self.assertRaises(UnCompareExeption, self.test1.insert, 3)
Пример #4
0
    def test(self):
        value = 5
        t = SplayTree()
        # test empty
        assert t.isEmpty()
        # we cannot splay if tree is empty
        assert t.splay(None) is None
        # we cannot find anything in empty tree
        assert t.find(1) is None
        assert t.findMin() is None
        assert t.findMax() is None
        # cannot remove from empty
        assert t.remove(123) is None

        # insert into empty tree
        t.insert(value)
        assert not t.isEmpty()

        # insert into non-empty tree same value
        t.insert(value)
        assert not t.isEmpty()

        # insert different values
        t = SplayTree()
        t.insert(3)
        t.insert(5)
        t.insert(1)

        assert t.findMin() == 1
        assert t.findMax() == 5
        assert t.find(3) == 3
        assert t.find(10) is None

        t = SplayTree()
        t.insert(5)
        t.insert(3)
        t.insert(1)
        assert t.find(3) == 3
        assert t.findMin() == 1

        # test remove
        t = SplayTree()
        t.insert(5)
        t.insert(3)
        t.insert(1)
        t.remove(5)
        t.remove(3)
        t.remove(1)
        assert t.isEmpty()

        # test Node.equals()
        n1 = Node(3)
        n2 = Node(2 + 1)
        n3 = Node(1)
        assert n1.equals(n2)
        assert not n1.equals(n3)

        t = SplayTree()
        t.insert(7)
        t.insert(3)
        t.insert(7)
        assert t.find(7) == 7

        # lets do som RANGE testing !
        max = 1000
        min = 100
        t = SplayTree()
        t.insert(min)
        t.insert(max)

        for i in range(101, 999, 10):
            t.insert(i)
            assert t.find(i) == i
            assert t.findMin() == min
            assert t.findMax() == max