test/TestQueueDict.py

   1 #! /usr/bin/python
   2
   3 import unittest
   4 import sys
   5 import random
   6
   7 sys.path.insert(0, '../src/lib')
   8 import QueueDict
   9
  10 class QueueDictTestCase(unittest.TestCase):
  11     def setUp(self):
  12         self.N_ITEMS = 100
  13         self._qd = QueueDict.FeedQD()
  14         self._order = False
  15         self._qd.sort_order = self._order
  16
  17         for value in xrange(self.N_ITEMS):
  18             for key in random.sample(xrange(self.N_ITEMS), self.N_ITEMS):
  19                 self._qd[key] = "Item#%d" % value
  20
  21     def getKeys(self):
  22         return self._qd.keys()
  23
  24     def pickRandomKey(self, keys):
  25         return random.choice(keys)
  26
  27     def getIndex(self, key):
  28         return self._qd.index(key)
  29
  30     def testIndex(self):
  31         keys = self.getKeys()
  32         key = self.pickRandomKey(keys)
  33         self.assertEqual(keys.index(key), self._qd.index(key))
  34
  35     def testKeys(self):
  36         self.failUnless(self.getKeys() > 0)
  37
  38     def testLength(self):
  39         self.assertEqual (self.N_ITEMS, len(self._qd))
  40
  41     def testSortOrder(self):
  42         self.assertEqual (self._order, self._qd.sort_order)
  43         self._qd.sort_order = not self._order
  44         self.assertNotEqual (self._order, self._qd.sort_order)
  45
  46     def testFirstItem(self):
  47         def tfi():
  48             items = self._qd.items()
  49             front = self._qd.get_first_item()
  50             self.failUnless(front is not None)
  51             self.assertEqual(items[0][1], front)
  52         # normal order
  53         tfi()
  54         # reversed order
  55         self._qd.sort_order = not self._order
  56         tfi()
  57
  58     def testLastItem(self):
  59         def lit():
  60             items = self._qd.items()
  61             back = self._qd.get_last_item()
  62             self.failUnless(back is not None)
  63             self.assertEqual(items[-1][1], back)
  64         # normal order
  65         lit()
  66         # reversed order
  67         self._qd.sort_order = not self._order
  68         lit()
  69
  70     def testNextItem(self):
  71         keys = self.getKeys()
  72         random_key = self.pickRandomKey(keys)
  73         next_keyidx = self.getIndex(random_key) + 1
  74         next_item = self._qd.get_next_item(random_key)
  75
  76         self.failUnless(next_keyidx is not None)
  77         self.failUnless(next_item is not None)
  78         self.assertEqual(self._qd.get(keys[next_keyidx]), next_item)
  79
  80     def testPreviousItem(self):
  81         keys = self.getKeys()
  82         random_key = self.pickRandomKey(keys)
  83         prev_keyidx = self.getIndex(random_key) - 1
  84         prev_item = self._qd.get_previous_item(random_key)
  85
  86         self.failUnless(prev_keyidx is not None)
  87         self.failUnless(prev_item is not None)
  88         self.assertEqual(self._qd.get(keys[prev_keyidx]), prev_item)
  89
  90
  91     def testNonExistentKey(self):
  92         # Value of a non-existent key should be None
  93         key = chr(int(random.random() * self.N_ITEMS))
  94         item = self._qd.get(key)
  95         self.failUnless (item is None)
  96
  97 def suite():
  98     suite = unittest.makeSuite(TestQueueDict, 'test')
  99     return suite
 100
 101 if __name__ == '__main__':
 102     unittest.main()
 103