def testLargeInserts(self):
        t = SplayTree()
        nums = 40000
        gap = 307
        i = gap

        while i != 0:
            t.insert(i)
            i = (i + gap) % nums
Esempio n. 2
0
def test_find():
    splay_tree = SplayTree()
    assert pytest.raises(ValueError, splay_tree.find, 1)

    splay_tree.insert(10, 10)
    splay_tree.insert(8, 8)
    splay_tree.insert(12, 12)

    assert splay_tree.find(8) == 8
    assert splay_tree.find(20) is None
class TestCase(unittest.TestCase):
    def setUp(self):
        self.keys = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        self.t = SplayTree()
        for key in self.keys:
            self.t.insert(key)

    def testInsert(self):
        for key in self.keys:
            self.assertEquals(key, self.t.find(key))

    def testRemove(self):
        for key in self.keys:
            self.t.remove(key)
            self.assertEquals(self.t.find(key), None)

    def testLargeInserts(self):
        t = SplayTree()
        nums = 40000
        gap = 307
        i = gap

        while i != 0:
            t.insert(i)
            i = (i + gap) % nums

    def testIsEmpty(self):
        self.assertFalse(self.t.isEmpty())
        t = SplayTree()
        self.assertTrue(t.isEmpty())

    def testMinMax(self):
        self.assertEquals(self.t.findMin(), 0)
        self.assertEquals(self.t.findMax(), 9)
Esempio n. 4
0
def test_remove():
    t = SplayTree()
    t.remove(1)
    t.insert(1)
    t.insert(2)
    t.remove(2)
    t.remove(1)
Esempio n. 5
0
    def testFind(self):
        """Test if items inserted into the splay tree can be found again."""

        N = randint(20, 150)
        s = SplayTree()
        for i in xrange(N):
            self.s.insert(i, 1)
        for i in xrange(N):
            a = self.s.find(i)
            self.assertTrue(a)
            N -= a

        self.assertEqual(N, 0)
Esempio n. 6
0
def test_findMin():
    t = SplayTree()
    assert (t.findMin() == None)
    t.insert(1)
    t.insert(2)
    assert (t.findMin() == 1)
Esempio n. 7
0
def test_insert():
    t = SplayTree()
    t.insert(1)
    t.insert(1)
Esempio n. 8
0
 def setUp(self):
     self.s = SplayTree()
Esempio n. 9
0
def test_isEmpty():
    t = SplayTree()
    assert (t.isEmpty())
Esempio n. 10
0
def test_insert():
    splay_tree = SplayTree()

    splay_tree.insert(10)
    splay_tree.insert(8)
    splay_tree.insert(12)
    splay_tree.insert(13)
    splay_tree.insert(7)

    x = splay_tree.pre_order(splay_tree.root(), [])

    assert x == [7, 8, 10, 12, 13]
Esempio n. 11
0
 def setUp(self):
   self.s = SplayTree()
Esempio n. 12
0
class TestSplayBasic(unittest.TestCase):

  def setUp(self):
    self.s = SplayTree()
    #self.mockSplay()

  def mockSplay(self):
    self.s.splay = lambda a : None

  def testConstructor(self):
    """Test if SplayTree can be constructed without raising an exception."""

    SplayTree()
    self.assertIsNotNone(self.s)
    self.assertIsInstance(self.s, SplayTree)

  def testInsert(self):
    """Test if SplayTree can be inserted into without raising an exception."""

    for i in xrange(randint(50,150)):
      self.s.insert(i, None)

  def testInsertLength(self):
    """Test if insertions into a splay tree result in the correct length."""

    num = randint(60,180)
    for i in xrange(num):
      self.s.insert(i, None)
    self.assertEqual(len(self.s), num)

    #try to insert duplicates
    for i in xrange(num):
      self.s.insert(i, None)
    self.assertEqual(len(self.s), num)

  def testRemove(self):
    """Test if a splay tree can be inserted into and removed without error."""

    numIns = randint(70,200)

    for i in xrange(numIns):
      self.s.insert(i, None)
    for i in xrange(numIns):
      self.s.remove(i)

  def testRemoveLengthSimple(self):
    """Test if a simple, insertion and removal result in the correct length."""

    a = randint(-2147483648,2147483647)
    self.s.insert(a, True)
    self.assertEqual(len(self.s), 1)
    self.s.remove(a)
    self.assertEqual(len(self.s), 0)

  def testRemoveLength(self):
    """Test if insertions into a splay tree result in the correct length.

    Use a python set to deal with duplicate insertions.

    """
    numIns = randint(60, 180)
    numRem = (numIns/2) + randint(0, numIns/2)
    ref = set()
    refStatic = set()

    for i in xrange(numIns):
      a = randint(-2147483648,2147483647)
      ref.add(a)
      refStatic.add(a)
      self.s.insert(a,True)

    self.assertEqual(len(self.s), len(ref))
    refLength = len(self.s)
    #pdb.set_trace()
    for i in xrange(numRem):
      self.assertEqual(len(self.s), refLength)
      refLength -=1
      self.s.remove(ref.pop())

    self.assertNotEqual(len(self.s), numIns)
    self.assertEqual(len(self.s), len(ref))

    for i in xrange(numRem): #try to re-remove items
      self.s.remove(refStatic.pop())

  def testFind(self):
    """Test if items inserted into the splay tree can be found again."""

    N = randint(20,150)
    s = SplayTree()
    for i in xrange(N):
      self.s.insert(i,1)
    for i in xrange(N):
      a = self.s.find(i)
      self.assertTrue(a)
      N-=a

    self.assertEqual(N, 0)

  def testContains(self):
    """Test if the number of items inserted into the tree can be re-found."""

    N = randint(20,100)
    for i in xrange(N):
      self.s.insert(i,True)
      N-=(i in self.s)

    self.assertEqual(N,0)
Esempio n. 13
0
 def setUp(self):
     self.keys = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
     self.t = SplayTree()
     for key in self.keys:
         self.t.insert(key)
Esempio n. 14
0
 def testIsEmpty(self):
     self.assertFalse(self.t.isEmpty())
     t = SplayTree()
     self.assertTrue(t.isEmpty())
Esempio n. 15
0
def test_findMax():
    t = SplayTree()
    assert (t.findMax() == None)
    t.insert(1)
    t.insert(-1)
    assert (t.findMax() == 1)
Esempio n. 16
0
    def testConstructor(self):
        """Test if SplayTree can be constructed without raising an exception."""

        SplayTree()
        self.assertIsNotNone(self.s)
        self.assertIsInstance(self.s, SplayTree)
Esempio n. 17
0
def test_find():
    t = SplayTree()
    assert (t.find(1) == None)
    t.insert(1)
    assert (t.find(1) == 1)
    assert (t.find(10) == None)
Esempio n. 18
0
class TestSplayBasic(unittest.TestCase):
    def setUp(self):
        self.s = SplayTree()
        #self.mockSplay()

    def mockSplay(self):
        self.s.splay = lambda a: None

    def testConstructor(self):
        """Test if SplayTree can be constructed without raising an exception."""

        SplayTree()
        self.assertIsNotNone(self.s)
        self.assertIsInstance(self.s, SplayTree)

    def testInsert(self):
        """Test if SplayTree can be inserted into without raising an exception."""

        for i in xrange(randint(50, 150)):
            self.s.insert(i, None)

    def testInsertLength(self):
        """Test if insertions into a splay tree result in the correct length."""

        num = randint(60, 180)
        for i in xrange(num):
            self.s.insert(i, None)
        self.assertEqual(len(self.s), num)

        #try to insert duplicates
        for i in xrange(num):
            self.s.insert(i, None)
        self.assertEqual(len(self.s), num)

    def testRemove(self):
        """Test if a splay tree can be inserted into and removed without error."""

        numIns = randint(70, 200)

        for i in xrange(numIns):
            self.s.insert(i, None)
        for i in xrange(numIns):
            self.s.remove(i)

    def testRemoveLengthSimple(self):
        """Test if a simple, insertion and removal result in the correct length."""

        a = randint(-2147483648, 2147483647)
        self.s.insert(a, True)
        self.assertEqual(len(self.s), 1)
        self.s.remove(a)
        self.assertEqual(len(self.s), 0)

    def testRemoveLength(self):
        """Test if insertions into a splay tree result in the correct length.

    Use a python set to deal with duplicate insertions.

    """
        numIns = randint(60, 180)
        numRem = (numIns / 2) + randint(0, numIns / 2)
        ref = set()
        refStatic = set()

        for i in xrange(numIns):
            a = randint(-2147483648, 2147483647)
            ref.add(a)
            refStatic.add(a)
            self.s.insert(a, True)

        self.assertEqual(len(self.s), len(ref))
        refLength = len(self.s)
        #pdb.set_trace()
        for i in xrange(numRem):
            self.assertEqual(len(self.s), refLength)
            refLength -= 1
            self.s.remove(ref.pop())

        self.assertNotEqual(len(self.s), numIns)
        self.assertEqual(len(self.s), len(ref))

        for i in xrange(numRem):  #try to re-remove items
            self.s.remove(refStatic.pop())

    def testFind(self):
        """Test if items inserted into the splay tree can be found again."""

        N = randint(20, 150)
        s = SplayTree()
        for i in xrange(N):
            self.s.insert(i, 1)
        for i in xrange(N):
            a = self.s.find(i)
            self.assertTrue(a)
            N -= a

        self.assertEqual(N, 0)

    def testContains(self):
        """Test if the number of items inserted into the tree can be re-found."""

        N = randint(20, 100)
        for i in xrange(N):
            self.s.insert(i, True)
            N -= (i in self.s)

        self.assertEqual(N, 0)
Esempio n. 19
0
def test_splay():
    t = SplayTree()
    t.insert(1)
    t.insert(2)
    t.insert(-1)
    t.insert(10)
    t.insert(5)
    t.splay(1)
    t.splay(1)

    t_ = SplayTree()
    t_.insert(2)
    t_.insert(1)
    t_.insert(10)
    t_.splay(2)
 def merge(tree1, tree2):
     tree = SplayTree.merge(tree1, tree2)
     SplayTreeWithSum.update_subtree_sum(tree.root)
     return tree