home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / pythonwin / python.exe / TEST_USERDICT.PY < prev    next >
Encoding:
Python Source  |  2003-05-02  |  12.9 KB  |  402 lines
  1. # Check every path through every method of UserDict
  2.  
  3. import test.test_support, unittest
  4. from sets import Set
  5.  
  6. import UserDict
  7.  
  8. class TestMappingProtocol(unittest.TestCase):
  9.     # This base class can be used to check that an object conforms to the
  10.     # mapping protocol
  11.  
  12.     # Functions that can be useful to override to adapt to dictionary
  13.     # semantics
  14.     _tested_class = dict   # which class is being tested
  15.  
  16.     def _reference(self):
  17.         """Return a dictionary of values which are invariant by storage
  18.         in the object under test."""
  19.         return {1:2, "key1":"value1", "key2":(1,2,3)}
  20.     def _empty_mapping(self):
  21.         """Return an empty mapping object"""
  22.         return self._tested_class()
  23.     def _full_mapping(self, data):
  24.         """Return a mapping object with the value contained in data
  25.         dictionary"""
  26.         x = self._empty_mapping()
  27.         for key, value in data.items():
  28.             x[key] = value
  29.         return x
  30.  
  31.     def __init__(self, *args, **kw):
  32.         unittest.TestCase.__init__(self, *args, **kw)
  33.         self.reference = self._reference().copy()
  34.         key, value = self.reference.popitem()
  35.         self.other = {key:value}
  36.  
  37.     def test_read(self):
  38.         # Test for read only operations on mapping
  39.         p = self._empty_mapping()
  40.         p1 = dict(p) #workaround for singleton objects
  41.         d = self._full_mapping(self.reference)
  42.         if d is p:
  43.             p = p1
  44.         #Indexing
  45.         for key, value in self.reference.items():
  46.             self.assertEqual(d[key], value)
  47.         knownkey = self.other.keys()[0]
  48.         self.failUnlessRaises(KeyError, lambda:d[knownkey])
  49.         #len
  50.         self.assertEqual(len(p), 0)
  51.         self.assertEqual(len(d), len(self.reference))
  52.         #has_key
  53.         for k in self.reference:
  54.             self.assert_(d.has_key(k))
  55.             self.assert_(k in d)
  56.         for k in self.other:
  57.             self.failIf(d.has_key(k))
  58.             self.failIf(k in d)
  59.         #cmp
  60.         self.assertEqual(cmp(p,p), 0)
  61.         self.assertEqual(cmp(d,d), 0)
  62.         self.assertEqual(cmp(p,d), -1)
  63.         self.assertEqual(cmp(d,p), 1)
  64.         #__non__zero__
  65.         if p: self.fail("Empty mapping must compare to False")
  66.         if not d: self.fail("Full mapping must compare to True")
  67.         # keys(), items(), iterkeys() ...
  68.         def check_iterandlist(iter, lst, ref):
  69.             self.assert_(hasattr(iter, 'next'))
  70.             self.assert_(hasattr(iter, '__iter__'))
  71.             x = list(iter)
  72.             self.assert_(Set(x)==Set(lst)==Set(ref))
  73.         check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
  74.         check_iterandlist(iter(d), d.keys(), self.reference.keys())
  75.         check_iterandlist(d.itervalues(), d.values(), self.reference.values())
  76.         check_iterandlist(d.iteritems(), d.items(), self.reference.items())
  77.         #get
  78.         key, value = d.iteritems().next()
  79.         knownkey, knownvalue = self.other.iteritems().next()
  80.         self.assertEqual(d.get(key, knownvalue), value)
  81.         self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
  82.         self.failIf(knownkey in d)
  83.  
  84.     def test_write(self):
  85.         # Test for write operations on mapping
  86.         p = self._empty_mapping()
  87.         #Indexing
  88.         for key, value in self.reference.items():
  89.             p[key] = value
  90.             self.assertEqual(p[key], value)
  91.         for key in self.reference.keys():
  92.             del p[key]
  93.             self.failUnlessRaises(KeyError, lambda:p[key])
  94.         p = self._empty_mapping()
  95.         #update
  96.         p.update(self.reference)
  97.         self.assertEqual(dict(p), self.reference)
  98.         d = self._full_mapping(self.reference)
  99.         #setdefaullt
  100.         key, value = d.iteritems().next()
  101.         knownkey, knownvalue = self.other.iteritems().next()
  102.         self.assertEqual(d.setdefault(key, knownvalue), value)
  103.         self.assertEqual(d[key], value)
  104.         self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
  105.         self.assertEqual(d[knownkey], knownvalue)
  106.         #pop
  107.         self.assertEqual(d.pop(knownkey), knownvalue)
  108.         self.failIf(knownkey in d)
  109.         self.assertRaises(KeyError, d.pop, knownkey)
  110.         default = 909
  111.         d[knownkey] = knownvalue
  112.         self.assertEqual(d.pop(knownkey, default), knownvalue)
  113.         self.failIf(knownkey in d)
  114.         self.assertEqual(d.pop(knownkey, default), default)
  115.         #popitem
  116.         key, value = d.popitem()
  117.         self.failIf(key in d)
  118.         self.assertEqual(value, self.reference[key])
  119.         p=self._empty_mapping()
  120.         self.assertRaises(KeyError, p.popitem)
  121.  
  122. d0 = {}
  123. d1 = {"one": 1}
  124. d2 = {"one": 1, "two": 2}
  125. d3 = {"one": 1, "two": 3, "three": 5}
  126. d4 = {"one": None, "two": None}
  127. d5 = {"one": 1, "two": 1}
  128.  
  129. class UserDictTest(TestMappingProtocol):
  130.     _tested_class = UserDict.IterableUserDict
  131.  
  132.     def test_all(self):
  133.         # Test constructors
  134.         u = UserDict.UserDict()
  135.         u0 = UserDict.UserDict(d0)
  136.         u1 = UserDict.UserDict(d1)
  137.         u2 = UserDict.IterableUserDict(d2)
  138.  
  139.         uu = UserDict.UserDict(u)
  140.         uu0 = UserDict.UserDict(u0)
  141.         uu1 = UserDict.UserDict(u1)
  142.         uu2 = UserDict.UserDict(u2)
  143.  
  144.         # keyword arg constructor
  145.         self.assertEqual(UserDict.UserDict(one=1, two=2), d2)
  146.         # item sequence constructor
  147.         self.assertEqual(UserDict.UserDict([('one',1), ('two',2)]), d2)
  148.         self.assertEqual(UserDict.UserDict(dict=[('one',1), ('two',2)]), d2)
  149.         # both together
  150.         self.assertEqual(UserDict.UserDict([('one',1), ('two',2)], two=3, three=5), d3)
  151.  
  152.         # alternate constructor
  153.         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4)
  154.         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4)
  155.         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5)
  156.         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5)
  157.         self.assert_(u1.fromkeys('one two'.split()) is not u1)
  158.         self.assert_(isinstance(u1.fromkeys('one two'.split()), UserDict.UserDict))
  159.         self.assert_(isinstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict))
  160.  
  161.         # Test __repr__
  162.         self.assertEqual(str(u0), str(d0))
  163.         self.assertEqual(repr(u1), repr(d1))
  164.         self.assertEqual(`u2`, `d2`)
  165.  
  166.         # Test __cmp__ and __len__
  167.         all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
  168.         for a in all:
  169.             for b in all:
  170.                 self.assertEqual(cmp(a, b), cmp(len(a), len(b)))
  171.  
  172.         # Test __getitem__
  173.         self.assertEqual(u2["one"], 1)
  174.         self.assertRaises(KeyError, u1.__getitem__, "two")
  175.  
  176.         # Test __setitem__
  177.         u3 = UserDict.UserDict(u2)
  178.         u3["two"] = 2
  179.         u3["three"] = 3
  180.  
  181.         # Test __delitem__
  182.         del u3["three"]
  183.         self.assertRaises(KeyError, u3.__delitem__, "three")
  184.  
  185.         # Test clear
  186.         u3.clear()
  187.         self.assertEqual(u3, {})
  188.  
  189.         # Test copy()
  190.         u2a = u2.copy()
  191.         self.assertEqual(u2a, u2)
  192.         u2b = UserDict.UserDict(x=42, y=23)
  193.         u2c = u2b.copy() # making a copy of a UserDict is special cased
  194.         self.assertEqual(u2b, u2c)
  195.  
  196.         class MyUserDict(UserDict.UserDict):
  197.             def display(self): print self
  198.  
  199.         m2 = MyUserDict(u2)
  200.         m2a = m2.copy()
  201.         self.assertEqual(m2a, m2)
  202.  
  203.         # SF bug #476616 -- copy() of UserDict subclass shared data
  204.         m2['foo'] = 'bar'
  205.         self.assertNotEqual(m2a, m2)
  206.  
  207.         # Test keys, items, values
  208.         self.assertEqual(u2.keys(), d2.keys())
  209.         self.assertEqual(u2.items(), d2.items())
  210.         self.assertEqual(u2.values(), d2.values())
  211.  
  212.         # Test has_key and "in".
  213.         for i in u2.keys():
  214.             self.assert_(u2.has_key(i))
  215.             self.assert_(i in u2)
  216.             self.assertEqual(u1.has_key(i), d1.has_key(i))
  217.             self.assertEqual(i in u1, i in d1)
  218.             self.assertEqual(u0.has_key(i), d0.has_key(i))
  219.             self.assertEqual(i in u0, i in d0)
  220.  
  221.         # Test update
  222.         t = UserDict.UserDict()
  223.         t.update(u2)
  224.         self.assertEqual(t, u2)
  225.         class Items:
  226.             def items(self):
  227.                 return (("x", 42), ("y", 23))
  228.         t = UserDict.UserDict()
  229.         t.update(Items())
  230.         self.assertEqual(t, {"x": 42, "y": 23})
  231.  
  232.         # Test get
  233.         for i in u2.keys():
  234.             self.assertEqual(u2.get(i), u2[i])
  235.             self.assertEqual(u1.get(i), d1.get(i))
  236.             self.assertEqual(u0.get(i), d0.get(i))
  237.  
  238.         # Test "in" iteration.
  239.         for i in xrange(20):
  240.             u2[i] = str(i)
  241.         ikeys = []
  242.         for k in u2:
  243.             ikeys.append(k)
  244.         keys = u2.keys()
  245.         self.assertEqual(Set(ikeys), Set(keys))
  246.  
  247.         # Test setdefault
  248.         t = UserDict.UserDict()
  249.         self.assertEqual(t.setdefault("x", 42), 42)
  250.         self.assert_(t.has_key("x"))
  251.         self.assertEqual(t.setdefault("x", 23), 42)
  252.  
  253.         # Test pop
  254.         t = UserDict.UserDict(x=42)
  255.         self.assertEqual(t.pop("x"), 42)
  256.         self.assertRaises(KeyError, t.pop, "x")
  257.         self.assertEqual(t.pop("x", 1), 1)
  258.         t["x"] = 42
  259.         self.assertEqual(t.pop("x", 1), 42)
  260.  
  261.         # Test popitem
  262.         t = UserDict.UserDict(x=42)
  263.         self.assertEqual(t.popitem(), ("x", 42))
  264.         self.assertRaises(KeyError, t.popitem)
  265.  
  266. ##########################
  267. # Test Dict Mixin
  268.  
  269. class SeqDict(UserDict.DictMixin):
  270.     """Dictionary lookalike implemented with lists.
  271.  
  272.     Used to test and demonstrate DictMixin
  273.     """
  274.     def __init__(self):
  275.         self.keylist = []
  276.         self.valuelist = []
  277.     def __getitem__(self, key):
  278.         try:
  279.             i = self.keylist.index(key)
  280.         except ValueError:
  281.             raise KeyError
  282.         return self.valuelist[i]
  283.     def __setitem__(self, key, value):
  284.         try:
  285.             i = self.keylist.index(key)
  286.             self.valuelist[i] = value
  287.         except ValueError:
  288.             self.keylist.append(key)
  289.             self.valuelist.append(value)
  290.     def __delitem__(self, key):
  291.         try:
  292.             i = self.keylist.index(key)
  293.         except ValueError:
  294.             raise KeyError
  295.         self.keylist.pop(i)
  296.         self.valuelist.pop(i)
  297.     def keys(self):
  298.         return list(self.keylist)
  299.  
  300. class UserDictMixinTest(TestMappingProtocol):
  301.     _tested_class = SeqDict
  302.  
  303.     def test_all(self):
  304.         ## Setup test and verify working of the test class
  305.  
  306.         # check init
  307.         s = SeqDict()
  308.  
  309.         # exercise setitem
  310.         s[10] = 'ten'
  311.         s[20] = 'twenty'
  312.         s[30] = 'thirty'
  313.  
  314.         # exercise delitem
  315.         del s[20]
  316.         # check getitem and setitem
  317.         self.assertEqual(s[10], 'ten')
  318.         # check keys() and delitem
  319.         self.assertEqual(s.keys(), [10, 30])
  320.  
  321.         ## Now, test the DictMixin methods one by one
  322.         # has_key
  323.         self.assert_(s.has_key(10))
  324.         self.assert_(not s.has_key(20))
  325.  
  326.         # __contains__
  327.         self.assert_(10 in s)
  328.         self.assert_(20 not in s)
  329.  
  330.         # __iter__
  331.         self.assertEqual([k for k in s], [10, 30])
  332.  
  333.         # __len__
  334.         self.assertEqual(len(s), 2)
  335.  
  336.         # iteritems
  337.         self.assertEqual(list(s.iteritems()), [(10,'ten'), (30, 'thirty')])
  338.  
  339.         # iterkeys
  340.         self.assertEqual(list(s.iterkeys()), [10, 30])
  341.  
  342.         # itervalues
  343.         self.assertEqual(list(s.itervalues()), ['ten', 'thirty'])
  344.  
  345.         # values
  346.         self.assertEqual(s.values(), ['ten', 'thirty'])
  347.  
  348.         # items
  349.         self.assertEqual(s.items(), [(10,'ten'), (30, 'thirty')])
  350.  
  351.         # get
  352.         self.assertEqual(s.get(10), 'ten')
  353.         self.assertEqual(s.get(15,'fifteen'), 'fifteen')
  354.         self.assertEqual(s.get(15), None)
  355.  
  356.         # setdefault
  357.         self.assertEqual(s.setdefault(40, 'forty'), 'forty')
  358.         self.assertEqual(s.setdefault(10, 'null'), 'ten')
  359.         del s[40]
  360.  
  361.         # pop
  362.         self.assertEqual(s.pop(10), 'ten')
  363.         self.assert_(10 not in s)
  364.         s[10] = 'ten'
  365.         self.assertEqual(s.pop("x", 1), 1)
  366.         s["x"] = 42
  367.         self.assertEqual(s.pop("x", 1), 42)
  368.  
  369.         # popitem
  370.         k, v = s.popitem()
  371.         self.assert_(k not in s)
  372.         s[k] = v
  373.  
  374.         # clear
  375.         s.clear()
  376.         self.assertEqual(len(s), 0)
  377.  
  378.         # empty popitem
  379.         self.assertRaises(KeyError, s.popitem)
  380.  
  381.         # update
  382.         s.update({10: 'ten', 20:'twenty'})
  383.         self.assertEqual(s[10], 'ten')
  384.         self.assertEqual(s[20], 'twenty')
  385.  
  386.         # cmp
  387.         self.assertEqual(s, {10: 'ten', 20:'twenty'})
  388.         t = SeqDict()
  389.         t[20] = 'twenty'
  390.         t[10] = 'ten'
  391.         self.assertEqual(s, t)
  392.  
  393. def test_main():
  394.     test.test_support.run_unittest(
  395.         TestMappingProtocol,
  396.         UserDictTest,
  397.         UserDictMixinTest
  398.     )
  399.  
  400. if __name__ == "__main__":
  401.     test_main()
  402.