home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 June / maximum-cd-2011-06.iso / DiscContents / LibO_3.3.1_Win_x86_install_multi.exe / libreoffice1.cab / test_userdict.py < prev    next >
Encoding:
Python Source  |  2011-02-15  |  10.3 KB  |  350 lines
  1. # Check every path through every method of UserDict
  2.  
  3. from test import test_support, mapping_tests
  4. import UserDict
  5.  
  6. d0 = {}
  7. d1 = {"one": 1}
  8. d2 = {"one": 1, "two": 2}
  9. d3 = {"one": 1, "two": 3, "three": 5}
  10. d4 = {"one": None, "two": None}
  11. d5 = {"one": 1, "two": 1}
  12.  
  13. class UserDictTest(mapping_tests.TestHashMappingProtocol):
  14.     type2test = UserDict.IterableUserDict
  15.  
  16.     def test_all(self):
  17.         # Test constructors
  18.         u = UserDict.UserDict()
  19.         u0 = UserDict.UserDict(d0)
  20.         u1 = UserDict.UserDict(d1)
  21.         u2 = UserDict.IterableUserDict(d2)
  22.  
  23.         uu = UserDict.UserDict(u)
  24.         uu0 = UserDict.UserDict(u0)
  25.         uu1 = UserDict.UserDict(u1)
  26.         uu2 = UserDict.UserDict(u2)
  27.  
  28.         # keyword arg constructor
  29.         self.assertEqual(UserDict.UserDict(one=1, two=2), d2)
  30.         # item sequence constructor
  31.         self.assertEqual(UserDict.UserDict([('one',1), ('two',2)]), d2)
  32.         self.assertEqual(UserDict.UserDict(dict=[('one',1), ('two',2)]), d2)
  33.         # both together
  34.         self.assertEqual(UserDict.UserDict([('one',1), ('two',2)], two=3, three=5), d3)
  35.  
  36.         # alternate constructor
  37.         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split()), d4)
  38.         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split()), d4)
  39.         self.assertEqual(UserDict.UserDict.fromkeys('one two'.split(), 1), d5)
  40.         self.assertEqual(UserDict.UserDict().fromkeys('one two'.split(), 1), d5)
  41.         self.assert_(u1.fromkeys('one two'.split()) is not u1)
  42.         self.assert_(isinstance(u1.fromkeys('one two'.split()), UserDict.UserDict))
  43.         self.assert_(isinstance(u2.fromkeys('one two'.split()), UserDict.IterableUserDict))
  44.  
  45.         # Test __repr__
  46.         self.assertEqual(str(u0), str(d0))
  47.         self.assertEqual(repr(u1), repr(d1))
  48.         self.assertEqual(`u2`, `d2`)
  49.  
  50.         # Test __cmp__ and __len__
  51.         all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
  52.         for a in all:
  53.             for b in all:
  54.                 self.assertEqual(cmp(a, b), cmp(len(a), len(b)))
  55.  
  56.         # Test __getitem__
  57.         self.assertEqual(u2["one"], 1)
  58.         self.assertRaises(KeyError, u1.__getitem__, "two")
  59.  
  60.         # Test __setitem__
  61.         u3 = UserDict.UserDict(u2)
  62.         u3["two"] = 2
  63.         u3["three"] = 3
  64.  
  65.         # Test __delitem__
  66.         del u3["three"]
  67.         self.assertRaises(KeyError, u3.__delitem__, "three")
  68.  
  69.         # Test clear
  70.         u3.clear()
  71.         self.assertEqual(u3, {})
  72.  
  73.         # Test copy()
  74.         u2a = u2.copy()
  75.         self.assertEqual(u2a, u2)
  76.         u2b = UserDict.UserDict(x=42, y=23)
  77.         u2c = u2b.copy() # making a copy of a UserDict is special cased
  78.         self.assertEqual(u2b, u2c)
  79.  
  80.         class MyUserDict(UserDict.UserDict):
  81.             def display(self): print self
  82.  
  83.         m2 = MyUserDict(u2)
  84.         m2a = m2.copy()
  85.         self.assertEqual(m2a, m2)
  86.  
  87.         # SF bug #476616 -- copy() of UserDict subclass shared data
  88.         m2['foo'] = 'bar'
  89.         self.assertNotEqual(m2a, m2)
  90.  
  91.         # Test keys, items, values
  92.         self.assertEqual(u2.keys(), d2.keys())
  93.         self.assertEqual(u2.items(), d2.items())
  94.         self.assertEqual(u2.values(), d2.values())
  95.  
  96.         # Test has_key and "in".
  97.         for i in u2.keys():
  98.             self.assert_(u2.has_key(i))
  99.             self.assert_(i in u2)
  100.             self.assertEqual(u1.has_key(i), d1.has_key(i))
  101.             self.assertEqual(i in u1, i in d1)
  102.             self.assertEqual(u0.has_key(i), d0.has_key(i))
  103.             self.assertEqual(i in u0, i in d0)
  104.  
  105.         # Test update
  106.         t = UserDict.UserDict()
  107.         t.update(u2)
  108.         self.assertEqual(t, u2)
  109.         class Items:
  110.             def items(self):
  111.                 return (("x", 42), ("y", 23))
  112.         t = UserDict.UserDict()
  113.         t.update(Items())
  114.         self.assertEqual(t, {"x": 42, "y": 23})
  115.  
  116.         # Test get
  117.         for i in u2.keys():
  118.             self.assertEqual(u2.get(i), u2[i])
  119.             self.assertEqual(u1.get(i), d1.get(i))
  120.             self.assertEqual(u0.get(i), d0.get(i))
  121.  
  122.         # Test "in" iteration.
  123.         for i in xrange(20):
  124.             u2[i] = str(i)
  125.         ikeys = []
  126.         for k in u2:
  127.             ikeys.append(k)
  128.         keys = u2.keys()
  129.         self.assertEqual(set(ikeys), set(keys))
  130.  
  131.         # Test setdefault
  132.         t = UserDict.UserDict()
  133.         self.assertEqual(t.setdefault("x", 42), 42)
  134.         self.assert_(t.has_key("x"))
  135.         self.assertEqual(t.setdefault("x", 23), 42)
  136.  
  137.         # Test pop
  138.         t = UserDict.UserDict(x=42)
  139.         self.assertEqual(t.pop("x"), 42)
  140.         self.assertRaises(KeyError, t.pop, "x")
  141.         self.assertEqual(t.pop("x", 1), 1)
  142.         t["x"] = 42
  143.         self.assertEqual(t.pop("x", 1), 42)
  144.  
  145.         # Test popitem
  146.         t = UserDict.UserDict(x=42)
  147.         self.assertEqual(t.popitem(), ("x", 42))
  148.         self.assertRaises(KeyError, t.popitem)
  149.  
  150.     def test_missing(self):
  151.         # Make sure UserDict doesn't have a __missing__ method
  152.         self.assertEqual(hasattr(UserDict, "__missing__"), False)
  153.         # Test several cases:
  154.         # (D) subclass defines __missing__ method returning a value
  155.         # (E) subclass defines __missing__ method raising RuntimeError
  156.         # (F) subclass sets __missing__ instance variable (no effect)
  157.         # (G) subclass doesn't define __missing__ at a all
  158.         class D(UserDict.UserDict):
  159.             def __missing__(self, key):
  160.                 return 42
  161.         d = D({1: 2, 3: 4})
  162.         self.assertEqual(d[1], 2)
  163.         self.assertEqual(d[3], 4)
  164.         self.assert_(2 not in d)
  165.         self.assert_(2 not in d.keys())
  166.         self.assertEqual(d[2], 42)
  167.         class E(UserDict.UserDict):
  168.             def __missing__(self, key):
  169.                 raise RuntimeError(key)
  170.         e = E()
  171.         try:
  172.             e[42]
  173.         except RuntimeError, err:
  174.             self.assertEqual(err.args, (42,))
  175.         else:
  176.             self.fail("e[42] didn't raise RuntimeError")
  177.         class F(UserDict.UserDict):
  178.             def __init__(self):
  179.                 # An instance variable __missing__ should have no effect
  180.                 self.__missing__ = lambda key: None
  181.                 UserDict.UserDict.__init__(self)
  182.         f = F()
  183.         try:
  184.             f[42]
  185.         except KeyError, err:
  186.             self.assertEqual(err.args, (42,))
  187.         else:
  188.             self.fail("f[42] didn't raise KeyError")
  189.         class G(UserDict.UserDict):
  190.             pass
  191.         g = G()
  192.         try:
  193.             g[42]
  194.         except KeyError, err:
  195.             self.assertEqual(err.args, (42,))
  196.         else:
  197.             self.fail("g[42] didn't raise KeyError")
  198.  
  199. ##########################
  200. # Test Dict Mixin
  201.  
  202. class SeqDict(UserDict.DictMixin):
  203.     """Dictionary lookalike implemented with lists.
  204.  
  205.     Used to test and demonstrate DictMixin
  206.     """
  207.     def __init__(self, other=None, **kwargs):
  208.         self.keylist = []
  209.         self.valuelist = []
  210.         if other is not None:
  211.             for (key, value) in other:
  212.                 self[key] = value
  213.         for (key, value) in kwargs.iteritems():
  214.             self[key] = value
  215.     def __getitem__(self, key):
  216.         try:
  217.             i = self.keylist.index(key)
  218.         except ValueError:
  219.             raise KeyError
  220.         return self.valuelist[i]
  221.     def __setitem__(self, key, value):
  222.         try:
  223.             i = self.keylist.index(key)
  224.             self.valuelist[i] = value
  225.         except ValueError:
  226.             self.keylist.append(key)
  227.             self.valuelist.append(value)
  228.     def __delitem__(self, key):
  229.         try:
  230.             i = self.keylist.index(key)
  231.         except ValueError:
  232.             raise KeyError
  233.         self.keylist.pop(i)
  234.         self.valuelist.pop(i)
  235.     def keys(self):
  236.         return list(self.keylist)
  237.     def copy(self):
  238.         d = self.__class__()
  239.         for key, value in self.iteritems():
  240.             d[key] = value
  241.         return d
  242.     @classmethod
  243.     def fromkeys(cls, keys, value=None):
  244.         d = cls()
  245.         for key in keys:
  246.             d[key] = value
  247.         return d
  248.  
  249. class UserDictMixinTest(mapping_tests.TestMappingProtocol):
  250.     type2test = SeqDict
  251.  
  252.     def test_all(self):
  253.         ## Setup test and verify working of the test class
  254.  
  255.         # check init
  256.         s = SeqDict()
  257.  
  258.         # exercise setitem
  259.         s[10] = 'ten'
  260.         s[20] = 'twenty'
  261.         s[30] = 'thirty'
  262.  
  263.         # exercise delitem
  264.         del s[20]
  265.         # check getitem and setitem
  266.         self.assertEqual(s[10], 'ten')
  267.         # check keys() and delitem
  268.         self.assertEqual(s.keys(), [10, 30])
  269.  
  270.         ## Now, test the DictMixin methods one by one
  271.         # has_key
  272.         self.assert_(s.has_key(10))
  273.         self.assert_(not s.has_key(20))
  274.  
  275.         # __contains__
  276.         self.assert_(10 in s)
  277.         self.assert_(20 not in s)
  278.  
  279.         # __iter__
  280.         self.assertEqual([k for k in s], [10, 30])
  281.  
  282.         # __len__
  283.         self.assertEqual(len(s), 2)
  284.  
  285.         # iteritems
  286.         self.assertEqual(list(s.iteritems()), [(10,'ten'), (30, 'thirty')])
  287.  
  288.         # iterkeys
  289.         self.assertEqual(list(s.iterkeys()), [10, 30])
  290.  
  291.         # itervalues
  292.         self.assertEqual(list(s.itervalues()), ['ten', 'thirty'])
  293.  
  294.         # values
  295.         self.assertEqual(s.values(), ['ten', 'thirty'])
  296.  
  297.         # items
  298.         self.assertEqual(s.items(), [(10,'ten'), (30, 'thirty')])
  299.  
  300.         # get
  301.         self.assertEqual(s.get(10), 'ten')
  302.         self.assertEqual(s.get(15,'fifteen'), 'fifteen')
  303.         self.assertEqual(s.get(15), None)
  304.  
  305.         # setdefault
  306.         self.assertEqual(s.setdefault(40, 'forty'), 'forty')
  307.         self.assertEqual(s.setdefault(10, 'null'), 'ten')
  308.         del s[40]
  309.  
  310.         # pop
  311.         self.assertEqual(s.pop(10), 'ten')
  312.         self.assert_(10 not in s)
  313.         s[10] = 'ten'
  314.         self.assertEqual(s.pop("x", 1), 1)
  315.         s["x"] = 42
  316.         self.assertEqual(s.pop("x", 1), 42)
  317.  
  318.         # popitem
  319.         k, v = s.popitem()
  320.         self.assert_(k not in s)
  321.         s[k] = v
  322.  
  323.         # clear
  324.         s.clear()
  325.         self.assertEqual(len(s), 0)
  326.  
  327.         # empty popitem
  328.         self.assertRaises(KeyError, s.popitem)
  329.  
  330.         # update
  331.         s.update({10: 'ten', 20:'twenty'})
  332.         self.assertEqual(s[10], 'ten')
  333.         self.assertEqual(s[20], 'twenty')
  334.  
  335.         # cmp
  336.         self.assertEqual(s, {10: 'ten', 20:'twenty'})
  337.         t = SeqDict()
  338.         t[20] = 'twenty'
  339.         t[10] = 'ten'
  340.         self.assertEqual(s, t)
  341.  
  342. def test_main():
  343.     test_support.run_unittest(
  344.         UserDictTest,
  345.         UserDictMixinTest
  346.     )
  347.  
  348. if __name__ == "__main__":
  349.     test_main()
  350.