Da

✏️ Editing: test_dict_version.py

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

# PEP 509 is implemented in CPython but other Python implementations
# don't require to implement it
_testcapi = import_helper.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_dont_change(d, d.__setitem__, 'key', value)

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

d2 = self.new_dict(key=value)
        self.check_version_dont_change(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)
        self.assertIsNot(value1, value2)

d = self.new_dict()
        self.check_version_changed(d, d.__setitem__, 'key', value1)
        self.assertIs(d['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)
        self.assertIs(d['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)
        self.assertIs(d['key'], value1)

d2 = self.new_dict(key=value2)
        self.check_version_changed(d, d.update, d2)
        self.assertIs(d['key'], value2)

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()

📁 Sid Gifari File Manager