/Lib/test/test_dict_version.py

"""
Test implementation of the PEP 509: dictionary versionning.
"""
import unittest
from test import support

# PEP 509 is implemented in CPython but other Python implementations
# don't require to implement it
_testcapi = support.import_module('_testcapi')


class DictVersionTests(unittest.TestCase):
    type2test = dict

    def setUp(self):
        self.seen_versions = set()
        self.dict = None

    def check_version_unique(self, mydict):
        version = _testcapi.dict_get_version(mydict)
        self.assertNotIn(version, self.seen_versions)
        self.seen_versions.add(version)

    def check_version_changed(self, mydict, method, *args, **kw):
        result = method(*args, **kw)
        self.check_version_unique(mydict)
        return result

    def check_version_dont_change(self, mydict, method, *args, **kw):
        version1 = _testcapi.dict_get_version(mydict)
        self.seen_versions.add(version1)

        result = method(*args, **kw)

        version2 = _testcapi.dict_get_version(mydict)
        self.assertEqual(version2, version1, "version changed")

        return  result

    def new_dict(self, *args, **kw):
        d = self.type2test(*args, **kw)
        self.check_version_unique(d)
        return d

    def test_constructor(self):
        # new empty dictionaries must all have an unique version
        empty1 = self.new_dict()
        empty2 = self.new_dict()
        empty3 = self.new_dict()

        # non-empty dictionaries must also have an unique version
        nonempty1 = self.new_dict(x='x')
        nonempty2 = self.new_dict(x='x', y='y')

    def test_copy(self):
        d = self.new_dict(a=1, b=2)

        d2 = self.check_version_dont_change(d, d.copy)

        # dict.copy() must create a dictionary with a new unique version
        self.check_version_unique(d2)

    def test_setitem(self):
        d = self.new_dict()

        # creating new keys must change the version
        self.check_version_changed(d, d.__setitem__, 'x', 'x')
        self.check_version_changed(d, d.__setitem__, 'y', 'y')

        # changing values must change the version
        self.check_version_changed(d, d.__setitem__, 'x', 1)
        self.check_version_changed(d, d.__setitem__, 'y', 2)

    def test_setitem_same_value(self):
        value = object()
        d = self.new_dict()

        # setting a key must change the version
        self.check_version_changed(d, d.__setitem__, 'key', value)

        # setting a key to the same value with dict.__setitem__
        # must change the version
        self.check_version_changed(d, d.__setitem__, 'key', value)

        # setting a key to the same value with dict.update
        # must change the version
        self.check_version_changed(d, d.update, key=value)

        d2 = self.new_dict(key=value)
        self.check_version_changed(d, d.update, d2)

    def test_setitem_equal(self):
        class AlwaysEqual:
            def __eq__(self, other):
                return True

        value1 = AlwaysEqual()
        value2 = AlwaysEqual()
        self.assertTrue(value1 == value2)
        self.assertFalse(value1 != value2)

        d = self.new_dict()
        self.check_version_changed(d, d.__setitem__, 'key', value1)

        # setting a key to a value equal to the current value
        # with dict.__setitem__() must change the version
        self.check_version_changed(d, d.__setitem__, 'key', value2)

        # setting a key to a value equal to the current value
        # with dict.update() must change the version
        self.check_version_changed(d, d.update, key=value1)

        d2 = self.new_dict(key=value2)
        self.check_version_changed(d, d.update, d2)

    def test_setdefault(self):
        d = self.new_dict()

        # setting a key with dict.setdefault() must change the version
        self.check_version_changed(d, d.setdefault, 'key', 'value1')

        # don't change the version if the key already exists
        self.check_version_dont_change(d, d.setdefault, 'key', 'value2')

    def test_delitem(self):
        d = self.new_dict(key='value')

        # deleting a key with dict.__delitem__() must change the version
        self.check_version_changed(d, d.__delitem__, 'key')

        # don't change the version if the key doesn't exist
        self.check_version_dont_change(d, self.assertRaises, KeyError,
                                       d.__delitem__, 'key')

    def test_pop(self):
        d = self.new_dict(key='value')

        # pop() must change the version if the key exists
        self.check_version_changed(d, d.pop, 'key')

        # pop() must not change the version if the key does not exist
        self.check_version_dont_change(d, self.assertRaises, KeyError,
                                       d.pop, 'key')

    def test_popitem(self):
        d = self.new_dict(key='value')

        # popitem() must change the version if the dict is not empty
        self.check_version_changed(d, d.popitem)

        # popitem() must not change the version if the dict is empty
        self.check_version_dont_change(d, self.assertRaises, KeyError,
                                       d.popitem)

    def test_update(self):
        d = self.new_dict(key='value')

        # update() calling with no argument must not change the version
        self.check_version_dont_change(d, d.update)

        # update() must change the version
        self.check_version_changed(d, d.update, key='new value')

        d2 = self.new_dict(key='value 3')
        self.check_version_changed(d, d.update, d2)

    def test_clear(self):
        d = self.new_dict(key='value')

        # clear() must change the version if the dict is not empty
        self.check_version_changed(d, d.clear)

        # clear() must not change the version if the dict is empty
        self.check_version_dont_change(d, d.clear)


class Dict(dict):
    pass


class DictSubtypeVersionTests(DictVersionTests):
    type2test = Dict


if __name__ == "__main__":
    unittest.main()