mirror of
https://github.com/django/django.git
synced 2025-10-24 06:06:09 +00:00
Refs #33476 -- Reformatted code with Black.
This commit is contained in:
django-bot
committed by
Mariusz Felisiak
Mariusz Felisiak
parent
f68fa8b45d
commit
9c19aff7c7
@@ -7,13 +7,16 @@ import pickle
|
||||
|
||||
from django.test import SimpleTestCase
|
||||
from django.utils.datastructures import (
|
||||
CaseInsensitiveMapping, DictWrapper, ImmutableList, MultiValueDict,
|
||||
MultiValueDictKeyError, OrderedSet,
|
||||
CaseInsensitiveMapping,
|
||||
DictWrapper,
|
||||
ImmutableList,
|
||||
MultiValueDict,
|
||||
MultiValueDictKeyError,
|
||||
OrderedSet,
|
||||
)
|
||||
|
||||
|
||||
class OrderedSetTests(SimpleTestCase):
|
||||
|
||||
def test_init_with_iterable(self):
|
||||
s = OrderedSet([1, 2, 3])
|
||||
self.assertEqual(list(s.dict.keys()), [1, 2, 3])
|
||||
@@ -61,80 +64,85 @@ class OrderedSetTests(SimpleTestCase):
|
||||
self.assertEqual(len(s), 2)
|
||||
|
||||
def test_repr(self):
|
||||
self.assertEqual(repr(OrderedSet()), 'OrderedSet()')
|
||||
self.assertEqual(repr(OrderedSet([2, 3, 2, 1])), 'OrderedSet([2, 3, 1])')
|
||||
self.assertEqual(repr(OrderedSet()), "OrderedSet()")
|
||||
self.assertEqual(repr(OrderedSet([2, 3, 2, 1])), "OrderedSet([2, 3, 1])")
|
||||
|
||||
|
||||
class MultiValueDictTests(SimpleTestCase):
|
||||
|
||||
def test_repr(self):
|
||||
d = MultiValueDict({'key': 'value'})
|
||||
d = MultiValueDict({"key": "value"})
|
||||
self.assertEqual(repr(d), "<MultiValueDict: {'key': 'value'}>")
|
||||
|
||||
def test_multivaluedict(self):
|
||||
d = MultiValueDict({'name': ['Adrian', 'Simon'], 'position': ['Developer'], 'empty': []})
|
||||
self.assertEqual(d['name'], 'Simon')
|
||||
self.assertEqual(d.get('name'), 'Simon')
|
||||
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
|
||||
d = MultiValueDict(
|
||||
{"name": ["Adrian", "Simon"], "position": ["Developer"], "empty": []}
|
||||
)
|
||||
self.assertEqual(d["name"], "Simon")
|
||||
self.assertEqual(d.get("name"), "Simon")
|
||||
self.assertEqual(d.getlist("name"), ["Adrian", "Simon"])
|
||||
self.assertEqual(
|
||||
list(d.items()),
|
||||
[('name', 'Simon'), ('position', 'Developer'), ('empty', [])]
|
||||
[("name", "Simon"), ("position", "Developer"), ("empty", [])],
|
||||
)
|
||||
self.assertEqual(
|
||||
list(d.lists()),
|
||||
[('name', ['Adrian', 'Simon']), ('position', ['Developer']), ('empty', [])]
|
||||
[("name", ["Adrian", "Simon"]), ("position", ["Developer"]), ("empty", [])],
|
||||
)
|
||||
with self.assertRaisesMessage(MultiValueDictKeyError, "'lastname'"):
|
||||
d.__getitem__('lastname')
|
||||
self.assertIsNone(d.get('empty'))
|
||||
self.assertEqual(d.get('empty', 'nonexistent'), 'nonexistent')
|
||||
self.assertIsNone(d.get('lastname'))
|
||||
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
|
||||
self.assertEqual(d.getlist('lastname'), [])
|
||||
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']), ['Adrian', 'Simon'])
|
||||
d.setlist('lastname', ['Holovaty', 'Willison'])
|
||||
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
|
||||
self.assertEqual(list(d.values()), ['Simon', 'Developer', [], 'Willison'])
|
||||
d.__getitem__("lastname")
|
||||
self.assertIsNone(d.get("empty"))
|
||||
self.assertEqual(d.get("empty", "nonexistent"), "nonexistent")
|
||||
self.assertIsNone(d.get("lastname"))
|
||||
self.assertEqual(d.get("lastname", "nonexistent"), "nonexistent")
|
||||
self.assertEqual(d.getlist("lastname"), [])
|
||||
self.assertEqual(
|
||||
d.getlist("doesnotexist", ["Adrian", "Simon"]), ["Adrian", "Simon"]
|
||||
)
|
||||
d.setlist("lastname", ["Holovaty", "Willison"])
|
||||
self.assertEqual(d.getlist("lastname"), ["Holovaty", "Willison"])
|
||||
self.assertEqual(list(d.values()), ["Simon", "Developer", [], "Willison"])
|
||||
|
||||
def test_appendlist(self):
|
||||
d = MultiValueDict()
|
||||
d.appendlist('name', 'Adrian')
|
||||
d.appendlist('name', 'Simon')
|
||||
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
|
||||
d.appendlist("name", "Adrian")
|
||||
d.appendlist("name", "Simon")
|
||||
self.assertEqual(d.getlist("name"), ["Adrian", "Simon"])
|
||||
|
||||
def test_copy(self):
|
||||
for copy_func in [copy.copy, lambda d: d.copy()]:
|
||||
with self.subTest(copy_func):
|
||||
d1 = MultiValueDict({'developers': ['Carl', 'Fred']})
|
||||
self.assertEqual(d1['developers'], 'Fred')
|
||||
d1 = MultiValueDict({"developers": ["Carl", "Fred"]})
|
||||
self.assertEqual(d1["developers"], "Fred")
|
||||
d2 = copy_func(d1)
|
||||
d2.update({'developers': 'Groucho'})
|
||||
self.assertEqual(d2['developers'], 'Groucho')
|
||||
self.assertEqual(d1['developers'], 'Fred')
|
||||
d2.update({"developers": "Groucho"})
|
||||
self.assertEqual(d2["developers"], "Groucho")
|
||||
self.assertEqual(d1["developers"], "Fred")
|
||||
|
||||
d1 = MultiValueDict({'key': [[]]})
|
||||
self.assertEqual(d1['key'], [])
|
||||
d1 = MultiValueDict({"key": [[]]})
|
||||
self.assertEqual(d1["key"], [])
|
||||
d2 = copy_func(d1)
|
||||
d2['key'].append('Penguin')
|
||||
self.assertEqual(d1['key'], ['Penguin'])
|
||||
self.assertEqual(d2['key'], ['Penguin'])
|
||||
d2["key"].append("Penguin")
|
||||
self.assertEqual(d1["key"], ["Penguin"])
|
||||
self.assertEqual(d2["key"], ["Penguin"])
|
||||
|
||||
def test_deepcopy(self):
|
||||
d1 = MultiValueDict({'a': [[123]]})
|
||||
d1 = MultiValueDict({"a": [[123]]})
|
||||
d2 = copy.copy(d1)
|
||||
d3 = copy.deepcopy(d1)
|
||||
self.assertIs(d1['a'], d2['a'])
|
||||
self.assertIsNot(d1['a'], d3['a'])
|
||||
self.assertIs(d1["a"], d2["a"])
|
||||
self.assertIsNot(d1["a"], d3["a"])
|
||||
|
||||
def test_pickle(self):
|
||||
x = MultiValueDict({'a': ['1', '2'], 'b': ['3']})
|
||||
x = MultiValueDict({"a": ["1", "2"], "b": ["3"]})
|
||||
self.assertEqual(x, pickle.loads(pickle.dumps(x)))
|
||||
|
||||
def test_dict_translation(self):
|
||||
mvd = MultiValueDict({
|
||||
'devs': ['Bob', 'Joe'],
|
||||
'pm': ['Rory'],
|
||||
})
|
||||
mvd = MultiValueDict(
|
||||
{
|
||||
"devs": ["Bob", "Joe"],
|
||||
"pm": ["Rory"],
|
||||
}
|
||||
)
|
||||
d = mvd.dict()
|
||||
self.assertEqual(list(d), list(mvd))
|
||||
for key in mvd:
|
||||
@@ -143,78 +151,78 @@ class MultiValueDictTests(SimpleTestCase):
|
||||
self.assertEqual({}, MultiValueDict().dict())
|
||||
|
||||
def test_getlist_doesnt_mutate(self):
|
||||
x = MultiValueDict({'a': ['1', '2'], 'b': ['3']})
|
||||
values = x.getlist('a')
|
||||
values += x.getlist('b')
|
||||
self.assertEqual(x.getlist('a'), ['1', '2'])
|
||||
x = MultiValueDict({"a": ["1", "2"], "b": ["3"]})
|
||||
values = x.getlist("a")
|
||||
values += x.getlist("b")
|
||||
self.assertEqual(x.getlist("a"), ["1", "2"])
|
||||
|
||||
def test_internal_getlist_does_mutate(self):
|
||||
x = MultiValueDict({'a': ['1', '2'], 'b': ['3']})
|
||||
values = x._getlist('a')
|
||||
values += x._getlist('b')
|
||||
self.assertEqual(x._getlist('a'), ['1', '2', '3'])
|
||||
x = MultiValueDict({"a": ["1", "2"], "b": ["3"]})
|
||||
values = x._getlist("a")
|
||||
values += x._getlist("b")
|
||||
self.assertEqual(x._getlist("a"), ["1", "2", "3"])
|
||||
|
||||
def test_getlist_default(self):
|
||||
x = MultiValueDict({'a': [1]})
|
||||
x = MultiValueDict({"a": [1]})
|
||||
MISSING = object()
|
||||
values = x.getlist('b', default=MISSING)
|
||||
values = x.getlist("b", default=MISSING)
|
||||
self.assertIs(values, MISSING)
|
||||
|
||||
def test_getlist_none_empty_values(self):
|
||||
x = MultiValueDict({'a': None, 'b': []})
|
||||
self.assertIsNone(x.getlist('a'))
|
||||
self.assertEqual(x.getlist('b'), [])
|
||||
x = MultiValueDict({"a": None, "b": []})
|
||||
self.assertIsNone(x.getlist("a"))
|
||||
self.assertEqual(x.getlist("b"), [])
|
||||
|
||||
def test_setitem(self):
|
||||
x = MultiValueDict({'a': [1, 2]})
|
||||
x['a'] = 3
|
||||
self.assertEqual(list(x.lists()), [('a', [3])])
|
||||
x = MultiValueDict({"a": [1, 2]})
|
||||
x["a"] = 3
|
||||
self.assertEqual(list(x.lists()), [("a", [3])])
|
||||
|
||||
def test_setdefault(self):
|
||||
x = MultiValueDict({'a': [1, 2]})
|
||||
a = x.setdefault('a', 3)
|
||||
b = x.setdefault('b', 3)
|
||||
x = MultiValueDict({"a": [1, 2]})
|
||||
a = x.setdefault("a", 3)
|
||||
b = x.setdefault("b", 3)
|
||||
self.assertEqual(a, 2)
|
||||
self.assertEqual(b, 3)
|
||||
self.assertEqual(list(x.lists()), [('a', [1, 2]), ('b', [3])])
|
||||
self.assertEqual(list(x.lists()), [("a", [1, 2]), ("b", [3])])
|
||||
|
||||
def test_update_too_many_args(self):
|
||||
x = MultiValueDict({'a': []})
|
||||
msg = 'update expected at most 1 argument, got 2'
|
||||
x = MultiValueDict({"a": []})
|
||||
msg = "update expected at most 1 argument, got 2"
|
||||
with self.assertRaisesMessage(TypeError, msg):
|
||||
x.update(1, 2)
|
||||
|
||||
def test_update_no_args(self):
|
||||
x = MultiValueDict({'a': []})
|
||||
x = MultiValueDict({"a": []})
|
||||
x.update()
|
||||
self.assertEqual(list(x.lists()), [('a', [])])
|
||||
self.assertEqual(list(x.lists()), [("a", [])])
|
||||
|
||||
def test_update_dict_arg(self):
|
||||
x = MultiValueDict({'a': [1], 'b': [2], 'c': [3]})
|
||||
x.update({'a': 4, 'b': 5})
|
||||
self.assertEqual(list(x.lists()), [('a', [1, 4]), ('b', [2, 5]), ('c', [3])])
|
||||
x = MultiValueDict({"a": [1], "b": [2], "c": [3]})
|
||||
x.update({"a": 4, "b": 5})
|
||||
self.assertEqual(list(x.lists()), [("a", [1, 4]), ("b", [2, 5]), ("c", [3])])
|
||||
|
||||
def test_update_multivaluedict_arg(self):
|
||||
x = MultiValueDict({'a': [1], 'b': [2], 'c': [3]})
|
||||
x.update(MultiValueDict({'a': [4], 'b': [5]}))
|
||||
self.assertEqual(list(x.lists()), [('a', [1, 4]), ('b', [2, 5]), ('c', [3])])
|
||||
x = MultiValueDict({"a": [1], "b": [2], "c": [3]})
|
||||
x.update(MultiValueDict({"a": [4], "b": [5]}))
|
||||
self.assertEqual(list(x.lists()), [("a", [1, 4]), ("b", [2, 5]), ("c", [3])])
|
||||
|
||||
def test_update_kwargs(self):
|
||||
x = MultiValueDict({'a': [1], 'b': [2], 'c': [3]})
|
||||
x = MultiValueDict({"a": [1], "b": [2], "c": [3]})
|
||||
x.update(a=4, b=5)
|
||||
self.assertEqual(list(x.lists()), [('a', [1, 4]), ('b', [2, 5]), ('c', [3])])
|
||||
self.assertEqual(list(x.lists()), [("a", [1, 4]), ("b", [2, 5]), ("c", [3])])
|
||||
|
||||
def test_update_with_empty_iterable(self):
|
||||
for value in ['', b'', (), [], set(), {}]:
|
||||
for value in ["", b"", (), [], set(), {}]:
|
||||
d = MultiValueDict()
|
||||
d.update(value)
|
||||
self.assertEqual(d, MultiValueDict())
|
||||
|
||||
def test_update_with_iterable_of_pairs(self):
|
||||
for value in [(('a', 1),), [('a', 1)], {('a', 1)}]:
|
||||
for value in [(("a", 1),), [("a", 1)], {("a", 1)}]:
|
||||
d = MultiValueDict()
|
||||
d.update(value)
|
||||
self.assertEqual(d, MultiValueDict({'a': [1]}))
|
||||
self.assertEqual(d, MultiValueDict({"a": [1]}))
|
||||
|
||||
def test_update_raises_correct_exceptions(self):
|
||||
# MultiValueDict.update() raises equivalent exceptions to
|
||||
@@ -224,26 +232,27 @@ class MultiValueDictTests(SimpleTestCase):
|
||||
with self.subTest(value), self.assertRaises(TypeError):
|
||||
MultiValueDict().update(value)
|
||||
# Iterables of objects that cannot be unpacked raise TypeError.
|
||||
for value in [b'123', b'abc', (1, 2, 3), [1, 2, 3], {1, 2, 3}]:
|
||||
for value in [b"123", b"abc", (1, 2, 3), [1, 2, 3], {1, 2, 3}]:
|
||||
with self.subTest(value), self.assertRaises(TypeError):
|
||||
MultiValueDict().update(value)
|
||||
# Iterables of unpackable objects with incorrect number of items raise
|
||||
# ValueError.
|
||||
for value in ['123', 'abc', ('a', 'b', 'c'), ['a', 'b', 'c'], {'a', 'b', 'c'}]:
|
||||
for value in ["123", "abc", ("a", "b", "c"), ["a", "b", "c"], {"a", "b", "c"}]:
|
||||
with self.subTest(value), self.assertRaises(ValueError):
|
||||
MultiValueDict().update(value)
|
||||
|
||||
|
||||
class ImmutableListTests(SimpleTestCase):
|
||||
|
||||
def test_sort(self):
|
||||
d = ImmutableList(range(10))
|
||||
|
||||
# AttributeError: ImmutableList object is immutable.
|
||||
with self.assertRaisesMessage(AttributeError, 'ImmutableList object is immutable.'):
|
||||
with self.assertRaisesMessage(
|
||||
AttributeError, "ImmutableList object is immutable."
|
||||
):
|
||||
d.sort()
|
||||
|
||||
self.assertEqual(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)')
|
||||
self.assertEqual(repr(d), "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)")
|
||||
|
||||
def test_custom_warning(self):
|
||||
d = ImmutableList(range(10), warning="Object is immutable!")
|
||||
@@ -251,64 +260,72 @@ class ImmutableListTests(SimpleTestCase):
|
||||
self.assertEqual(d[1], 1)
|
||||
|
||||
# AttributeError: Object is immutable!
|
||||
with self.assertRaisesMessage(AttributeError, 'Object is immutable!'):
|
||||
d.__setitem__(1, 'test')
|
||||
with self.assertRaisesMessage(AttributeError, "Object is immutable!"):
|
||||
d.__setitem__(1, "test")
|
||||
|
||||
|
||||
class DictWrapperTests(SimpleTestCase):
|
||||
|
||||
def test_dictwrapper(self):
|
||||
def f(x):
|
||||
return "*%s" % x
|
||||
d = DictWrapper({'a': 'a'}, f, 'xx_')
|
||||
|
||||
d = DictWrapper({"a": "a"}, f, "xx_")
|
||||
self.assertEqual(
|
||||
"Normal: %(a)s. Modified: %(xx_a)s" % d,
|
||||
'Normal: a. Modified: *a'
|
||||
"Normal: %(a)s. Modified: %(xx_a)s" % d, "Normal: a. Modified: *a"
|
||||
)
|
||||
|
||||
|
||||
class CaseInsensitiveMappingTests(SimpleTestCase):
|
||||
def setUp(self):
|
||||
self.dict1 = CaseInsensitiveMapping({
|
||||
'Accept': 'application/json',
|
||||
'content-type': 'text/html',
|
||||
})
|
||||
self.dict1 = CaseInsensitiveMapping(
|
||||
{
|
||||
"Accept": "application/json",
|
||||
"content-type": "text/html",
|
||||
}
|
||||
)
|
||||
|
||||
def test_create_with_invalid_values(self):
|
||||
msg = 'dictionary update sequence element #1 has length 4; 2 is required'
|
||||
msg = "dictionary update sequence element #1 has length 4; 2 is required"
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
CaseInsensitiveMapping([('Key1', 'Val1'), 'Key2'])
|
||||
CaseInsensitiveMapping([("Key1", "Val1"), "Key2"])
|
||||
|
||||
def test_create_with_invalid_key(self):
|
||||
msg = 'Element key 1 invalid, only strings are allowed'
|
||||
msg = "Element key 1 invalid, only strings are allowed"
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
CaseInsensitiveMapping([(1, '2')])
|
||||
CaseInsensitiveMapping([(1, "2")])
|
||||
|
||||
def test_list(self):
|
||||
self.assertEqual(list(self.dict1), ['Accept', 'content-type'])
|
||||
self.assertEqual(list(self.dict1), ["Accept", "content-type"])
|
||||
|
||||
def test_dict(self):
|
||||
self.assertEqual(dict(self.dict1), {'Accept': 'application/json', 'content-type': 'text/html'})
|
||||
self.assertEqual(
|
||||
dict(self.dict1),
|
||||
{"Accept": "application/json", "content-type": "text/html"},
|
||||
)
|
||||
|
||||
def test_repr(self):
|
||||
dict1 = CaseInsensitiveMapping({'Accept': 'application/json'})
|
||||
dict2 = CaseInsensitiveMapping({'content-type': 'text/html'})
|
||||
self.assertEqual(repr(dict1), repr({'Accept': 'application/json'}))
|
||||
self.assertEqual(repr(dict2), repr({'content-type': 'text/html'}))
|
||||
dict1 = CaseInsensitiveMapping({"Accept": "application/json"})
|
||||
dict2 = CaseInsensitiveMapping({"content-type": "text/html"})
|
||||
self.assertEqual(repr(dict1), repr({"Accept": "application/json"}))
|
||||
self.assertEqual(repr(dict2), repr({"content-type": "text/html"}))
|
||||
|
||||
def test_str(self):
|
||||
dict1 = CaseInsensitiveMapping({'Accept': 'application/json'})
|
||||
dict2 = CaseInsensitiveMapping({'content-type': 'text/html'})
|
||||
self.assertEqual(str(dict1), str({'Accept': 'application/json'}))
|
||||
self.assertEqual(str(dict2), str({'content-type': 'text/html'}))
|
||||
dict1 = CaseInsensitiveMapping({"Accept": "application/json"})
|
||||
dict2 = CaseInsensitiveMapping({"content-type": "text/html"})
|
||||
self.assertEqual(str(dict1), str({"Accept": "application/json"}))
|
||||
self.assertEqual(str(dict2), str({"content-type": "text/html"}))
|
||||
|
||||
def test_equal(self):
|
||||
self.assertEqual(self.dict1, {'Accept': 'application/json', 'content-type': 'text/html'})
|
||||
self.assertNotEqual(self.dict1, {'accept': 'application/jso', 'Content-Type': 'text/html'})
|
||||
self.assertNotEqual(self.dict1, 'string')
|
||||
self.assertEqual(
|
||||
self.dict1, {"Accept": "application/json", "content-type": "text/html"}
|
||||
)
|
||||
self.assertNotEqual(
|
||||
self.dict1, {"accept": "application/jso", "Content-Type": "text/html"}
|
||||
)
|
||||
self.assertNotEqual(self.dict1, "string")
|
||||
|
||||
def test_items(self):
|
||||
other = {'Accept': 'application/json', 'content-type': 'text/html'}
|
||||
other = {"Accept": "application/json", "content-type": "text/html"}
|
||||
self.assertEqual(sorted(self.dict1.items()), sorted(other.items()))
|
||||
|
||||
def test_copy(self):
|
||||
@@ -317,30 +334,30 @@ class CaseInsensitiveMappingTests(SimpleTestCase):
|
||||
self.assertEqual(copy, self.dict1)
|
||||
|
||||
def test_getitem(self):
|
||||
self.assertEqual(self.dict1['Accept'], 'application/json')
|
||||
self.assertEqual(self.dict1['accept'], 'application/json')
|
||||
self.assertEqual(self.dict1['aCCept'], 'application/json')
|
||||
self.assertEqual(self.dict1['content-type'], 'text/html')
|
||||
self.assertEqual(self.dict1['Content-Type'], 'text/html')
|
||||
self.assertEqual(self.dict1['Content-type'], 'text/html')
|
||||
self.assertEqual(self.dict1["Accept"], "application/json")
|
||||
self.assertEqual(self.dict1["accept"], "application/json")
|
||||
self.assertEqual(self.dict1["aCCept"], "application/json")
|
||||
self.assertEqual(self.dict1["content-type"], "text/html")
|
||||
self.assertEqual(self.dict1["Content-Type"], "text/html")
|
||||
self.assertEqual(self.dict1["Content-type"], "text/html")
|
||||
|
||||
def test_in(self):
|
||||
self.assertIn('Accept', self.dict1)
|
||||
self.assertIn('accept', self.dict1)
|
||||
self.assertIn('aCCept', self.dict1)
|
||||
self.assertIn('content-type', self.dict1)
|
||||
self.assertIn('Content-Type', self.dict1)
|
||||
self.assertIn("Accept", self.dict1)
|
||||
self.assertIn("accept", self.dict1)
|
||||
self.assertIn("aCCept", self.dict1)
|
||||
self.assertIn("content-type", self.dict1)
|
||||
self.assertIn("Content-Type", self.dict1)
|
||||
|
||||
def test_del(self):
|
||||
self.assertIn('Accept', self.dict1)
|
||||
self.assertIn("Accept", self.dict1)
|
||||
msg = "'CaseInsensitiveMapping' object does not support item deletion"
|
||||
with self.assertRaisesMessage(TypeError, msg):
|
||||
del self.dict1['Accept']
|
||||
self.assertIn('Accept', self.dict1)
|
||||
del self.dict1["Accept"]
|
||||
self.assertIn("Accept", self.dict1)
|
||||
|
||||
def test_set(self):
|
||||
self.assertEqual(len(self.dict1), 2)
|
||||
msg = "'CaseInsensitiveMapping' object does not support item assignment"
|
||||
with self.assertRaisesMessage(TypeError, msg):
|
||||
self.dict1['New Key'] = 1
|
||||
self.dict1["New Key"] = 1
|
||||
self.assertEqual(len(self.dict1), 2)
|
||||
|
||||
Reference in New Issue
Block a user