[Python-checkins] python/dist/src/Lib/test mapping_tests.py, NONE, 1.1 test_os.py, 1.21, 1.22 test_shelve.py, 1.6, 1.7 test_types.py, 1.59, 1.60 test_userdict.py, 1.18, 1.19 test_weakref.py, 1.38, 1.39 (original) (raw)

Mon May 31 12:29:09 EDT 2004

# Functions that can be useful to override to adapt to dictionary
# semantics
_tested_class = None # which class is being tested (overwrite in subclasses)

def _reference(self):
    """Return a dictionary of values which are invariant by storage
    in the object under test."""
    return {1:2, "key1":"value1", "key2":(1,2,3)}
def _empty_mapping(self):
    """Return an empty mapping object"""
    return self._tested_class()
def _full_mapping(self, data):
    """Return a mapping object with the value contained in data
    dictionary"""
    x = self._empty_mapping()
    for key, value in data.items():
        x[key] = value
    return x

def __init__(self, *args, **kw):
    unittest.TestCase.__init__(self, *args, **kw)
    self.reference = self._reference().copy()

    # A (key, value) pair not in the mapping
    key, value = self.reference.popitem()
    self.other = {key:value}

    # A (key, value) pair in the mapping
    key, value = self.reference.popitem()
    self.inmapping = {key:value}
    self.reference[key] = value

def test_read(self):
    # Test for read only operations on mapping
    p = self._empty_mapping()
    p1 = dict(p) #workaround for singleton objects
    d = self._full_mapping(self.reference)
    if d is p:
        p = p1
    #Indexing
    for key, value in self.reference.items():
        self.assertEqual(d[key], value)
    knownkey = self.other.keys()[0]
    self.failUnlessRaises(KeyError, lambda:d[knownkey])
    #len
    self.assertEqual(len(p), 0)
    self.assertEqual(len(d), len(self.reference))
    #has_key
    for k in self.reference:
        self.assert_(d.has_key(k))
        self.assert_(k in d)
    for k in self.other:
        self.failIf(d.has_key(k))
        self.failIf(k in d)
    #cmp
    self.assertEqual(cmp(p,p), 0)
    self.assertEqual(cmp(d,d), 0)
    self.assertEqual(cmp(p,d), -1)
    self.assertEqual(cmp(d,p), 1)
    #__non__zero__
    if p: self.fail("Empty mapping must compare to False")
    if not d: self.fail("Full mapping must compare to True")
    # keys(), items(), iterkeys() ...
    def check_iterandlist(iter, lst, ref):
        self.assert_(hasattr(iter, 'next'))
        self.assert_(hasattr(iter, '__iter__'))
        x = list(iter)
        self.assert_(set(x)==set(lst)==set(ref))
    check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
    check_iterandlist(iter(d), d.keys(), self.reference.keys())
    check_iterandlist(d.itervalues(), d.values(), self.reference.values())
    check_iterandlist(d.iteritems(), d.items(), self.reference.items())
    #get
    key, value = d.iteritems().next()
    knownkey, knownvalue = self.other.iteritems().next()
    self.assertEqual(d.get(key, knownvalue), value)
    self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
    self.failIf(knownkey in d)

def test_write(self):
    # Test for write operations on mapping
    p = self._empty_mapping()
    #Indexing
    for key, value in self.reference.items():
        p[key] = value
        self.assertEqual(p[key], value)
    for key in self.reference.keys():
        del p[key]
        self.failUnlessRaises(KeyError, lambda:p[key])
    p = self._empty_mapping()
    #update
    p.update(self.reference)
    self.assertEqual(dict(p), self.reference)
    items = p.items()
    p = self._empty_mapping()
    p.update(items)
    self.assertEqual(dict(p), self.reference)
    d = self._full_mapping(self.reference)
    #setdefault
    key, value = d.iteritems().next()
    knownkey, knownvalue = self.other.iteritems().next()
    self.assertEqual(d.setdefault(key, knownvalue), value)
    self.assertEqual(d[key], value)
    self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
    self.assertEqual(d[knownkey], knownvalue)
    #pop
    self.assertEqual(d.pop(knownkey), knownvalue)
    self.failIf(knownkey in d)
    self.assertRaises(KeyError, d.pop, knownkey)
    default = 909
    d[knownkey] = knownvalue
    self.assertEqual(d.pop(knownkey, default), knownvalue)
    self.failIf(knownkey in d)
    self.assertEqual(d.pop(knownkey, default), default)
    #popitem
    key, value = d.popitem()
    self.failIf(key in d)
    self.assertEqual(value, self.reference[key])
    p=self._empty_mapping()
    self.assertRaises(KeyError, p.popitem)

def test_constructor(self):
    self.assertEqual(self._empty_mapping(), self._empty_mapping())

def test_bool(self):
    self.assert_(not self._empty_mapping())
    self.assert_(self.reference)
    self.assert_(bool(self._empty_mapping()) is False)
    self.assert_(bool(self.reference) is True)

def test_keys(self):
    d = self._empty_mapping()
    self.assertEqual(d.keys(), [])
    d = self.reference
    self.assert_(self.inmapping.keys()[0] in d.keys())
    self.assert_(self.other.keys()[0] not in d.keys())
    self.assertRaises(TypeError, d.keys, None)

def test_values(self):
    d = self._empty_mapping()
    self.assertEqual(d.values(), [])

    self.assertRaises(TypeError, d.values, None)

def test_items(self):
    d = self._empty_mapping()
    self.assertEqual(d.items(), [])

    self.assertRaises(TypeError, d.items, None)

def test_len(self):
    d = self._empty_mapping()
    self.assertEqual(len(d), 0)

def test_getitem(self):
    d = self.reference
    self.assertEqual(d[self.inmapping.keys()[0]], self.inmapping.values()[0])

    self.assertRaises(TypeError, d.__getitem__)

def test_update(self):
    # mapping argument
    d = self._empty_mapping()
    d.update(self.other)
    self.assertEqual(d.items(), self.other.items())

    # No argument
    d = self._empty_mapping()
    d.update()
    self.assertEqual(d, self._empty_mapping())

    # item sequence
    d = self._empty_mapping()
    d.update(self.other.items())
    self.assertEqual(d.items(), self.other.items())

    # Iterator
    d = self._empty_mapping()
    d.update(self.other.iteritems())
    self.assertEqual(d.items(), self.other.items())

    # FIXME: Doesn't work with UserDict
    # self.assertRaises((TypeError, AttributeError), d.update, None)
    self.assertRaises((TypeError, AttributeError), d.update, 42)

    outerself = self
    class SimpleUserDict:
        def __init__(self):
            self.d = outerself.reference
        def keys(self):
            return self.d.keys()
        def __getitem__(self, i):
            return self.d[i]
    d.clear()
    d.update(SimpleUserDict())
    i1 = d.items()
    i2 = self.reference.items()
    i1.sort()
    i2.sort()
    self.assertEqual(i1, i2)

    class Exc(Exception): pass

    d = self._empty_mapping()
    class FailingUserDict:
        def keys(self):
            raise Exc
    self.assertRaises(Exc, d.update, FailingUserDict())

    d.clear()

    class FailingUserDict:
        def keys(self):
            class BogonIter:
                def __init__(self):
                    self.i = 1
                def __iter__(self):
                    return self
                def next(self):
                    if self.i:
                        self.i = 0
                        return 'a'
                    raise Exc
            return BogonIter()
        def __getitem__(self, key):
            return key
    self.assertRaises(Exc, d.update, FailingUserDict())

    class FailingUserDict:
        def keys(self):
            class BogonIter:
                def __init__(self):
                    self.i = ord('a')
                def __iter__(self):
                    return self
                def next(self):
                    if self.i <= ord('z'):
                        rtn = chr(self.i)
                        self.i += 1
                        return rtn
                    raise StopIteration
            return BogonIter()
        def __getitem__(self, key):
            raise Exc
    self.assertRaises(Exc, d.update, FailingUserDict())

    d = self._empty_mapping()
    class badseq(object):
        def __iter__(self):
            return self
        def next(self):
            raise Exc()

    self.assertRaises(Exc, d.update, badseq())

    self.assertRaises(ValueError, d.update, [(1, 2, 3)])

# no test_fromkeys or test_copy as both os.environ and selves don't support it

def test_get(self):
    d = self._empty_mapping()
    self.assert_(d.get(self.other.keys()[0]) is None)
    self.assertEqual(d.get(self.other.keys()[0], 3), 3)
    d = self.reference
    self.assert_(d.get(self.other.keys()[0]) is None)
    self.assertEqual(d.get(self.other.keys()[0], 3), 3)
    self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0])
    self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0])
    self.assertRaises(TypeError, d.get)
    self.assertRaises(TypeError, d.get, None, None, None)

def test_setdefault(self):
    d = self._empty_mapping()
    self.assertRaises(TypeError, d.setdefault)

def test_popitem(self):
    d = self._empty_mapping()
    self.assertRaises(KeyError, d.popitem)
    self.assertRaises(TypeError, d.popitem, 42)

def test_pop(self):
    d = self._empty_mapping()
    k, v = self.inmapping.items()[0]
    d[k] = v
    self.assertRaises(KeyError, d.pop, self.other.keys()[0])

    self.assertEqual(d.pop(k), v)
    self.assertEqual(len(d), 0)

    self.assertRaises(KeyError, d.pop, k)

[Python-checkins] python/dist/src/Lib/test mapping_tests.py, NONE, 1.1 test_os.py, 1.21, 1.22 test_shelve.py, 1.6, 1.7 test_types.py, 1.59, 1.60 test_userdict.py, 1.18, 1.19 test_weakref.py, 1.38, 1.39 (original) (raw)

tests common to dict and UserDict

Index: test_os.py

Index: test_shelve.py

Index: test_types.py

Tests for pop with specified key

verify longs/ints get same value when key > 32 bits (for 64-bit archs)

see SF bug #689659

Index: test_userdict.py

Check every path through every method of UserDict

Index: test_weakref.py