18199243591

Committed 02 Oct 2025 04:27PM UTC coverage: 94.822%. First build

Build # 18199243591

Build Type

Pull #1190

github

Committed by

web-flow

Commit Message

Merge 3b94e8f0a into 636f26578

Pull Request Pull Request #1190: Add More Multidict Functions C-API

Run Details

622 of 622 branches covered (100.0%)

Branch coverage included in aggregate %.

183 of 257 new or added lines in 1 file covered. (71.21%)

4103 of 4361 relevant lines covered (94.08%)

1.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.73

/tests/test_capi.py

import pytest

from multidict import MultiDict, MultiDictProxy, istr, CIMultiDict, CIMultiDictProxy

pytest.importorskip("multidict._multidict")
# We need this extension since there was no other decent way to
# compile it as a seperate project. the only logical solution was
# to inject it directly.
testcapi = pytest.importorskip("multidict._testcapi")

pytestmark = pytest.mark.capi

MultiDictStr = MultiDict[str]
MultiDictProxyStr = MultiDictProxy[str]

CIMultiDictStr = CIMultiDict[str]
CIMultiDictProxyStr = MultiDictProxy[str]


def test_md_add() -> None:
    md: MultiDictStr = MultiDict()
    testcapi.md_add(md, "key", "value")
    assert len(md) == 1
    assert list(md.items()) == [("key", "value")]


def test_md_clear() -> None:
    previous = MultiDict([("key", "value")])
    md: MultiDictStr = previous.copy()
    testcapi.md_clear(md)
    assert md != previous


def test_md_contains() -> None:
    d = MultiDict([("key", "one")])
    assert testcapi.md_contains(d, "key")
    testcapi.md_del(d, "key")
    assert testcapi.md_contains(d, "key") is False


def test_md_del() -> None:
    d = MultiDict([("key", "one"), ("key", "two")], foo="bar")
    assert list(d.keys()) == ["key", "key", "foo"]

    testcapi.md_del(d, "key")
    assert d == {"foo": "bar"}
    assert list(d.items()) == [("foo", "bar")]

    with pytest.raises(KeyError, match="key"):
        testcapi.md_del(d, "key")


def test_md_get_all() -> None:
    d: MultiDictStr = MultiDict()
    d.add("key1", "val1")
    d.add("key2", "val2")
    d.add("key1", "val3")
    ret = testcapi.md_getall(d, "key1")
    assert (["val1", "val3"], True) == ret


def test_md_get_all_miss() -> None:
    d = MultiDict([("key", "value1")], key="value2")
    assert testcapi.md_getall(d, "x")[1] is False


def test_md_getone() -> None:
    d: MultiDictStr = MultiDict(key="val1")
    d.add("key", "val2")
    assert testcapi.md_getone(d, "key") == ("val1", True)


def test_md_getone_miss() -> None:
    d: MultiDictStr = MultiDict([("key", "value1")], key="value2")
    assert testcapi.md_getone(d, "x")[1] is False


def test_md_new() -> None:
    md = testcapi.md_new(0)
    assert isinstance(md, MultiDict)
    assert len(md) == 0


def test_md_popall() -> None:
    d: MultiDictStr = MultiDict()

    d.add("key1", "val1")
    d.add("key2", "val2")
    d.add("key1", "val3")
    ret = testcapi.md_popall(d, "key1")
    assert (["val1", "val3"], True) == ret
    assert {"key2": "val2"} == d


def test_md_popall_key_miss() -> None:
    d: MultiDictStr = MultiDict()
    assert testcapi.md_popall(d, "x")[1] is False


def test_md_popone() -> None:
    d: MultiDictStr = MultiDict()
    d.add("key", "val1")
    d.add("key2", "val2")
    d.add("key", "val3")

    assert ("val1", True) == testcapi.md_popone(d, "key")
    assert [("key2", "val2"), ("key", "val3")] == list(d.items())


def test_md_popone_miss() -> None:
    d: MultiDictStr = MultiDict(other="val")
    assert testcapi.md_popone(d, "x")[1] is False


def test_md_popitem() -> None:
    d: MultiDictStr = MultiDict()
    d.add("key", "val1")
    d.add("key", "val2")

    assert ("key", "val2") == testcapi.md_popitem(d)
    assert len(d) == 1
    assert [("key", "val1")] == list(d.items())


def test_md_replace() -> None:
    d: MultiDictStr = MultiDict()
    d.add("key", "val1")
    testcapi.md_replace(d, "key", "val2")
    assert "val2" == d["key"]
    testcapi.md_replace(d, "key", "val3")
    assert "val3" == d["key"]


def test_md_setdefault() -> None:
    md: MultiDictStr = MultiDict([("key", "one"), ("key", "two")], foo="bar")
    assert ("one", True) == testcapi.md_setdefault(md, "key", "three")
    assert (None, False) == testcapi.md_setdefault(md, "otherkey", "three")
    assert "otherkey" in md
    assert "three" == md["otherkey"]


def test_md_update_from_md() -> None:
    d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})
    d2: MultiDictStr = MultiDict({"foo": "bar", "k": "v2"})

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )


def test_md_update_from_mdproxy() -> None:
    d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})
    d2: MultiDictProxyStr = MultiDictProxy(MultiDict({"foo": "bar", "k": "v2"}))

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_md_update_from_dict() -> None:
    d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})
    d2 = {"foo": "bar", "k": "v2"}

    d = d1.copy()
    testcapi.md_update_from_dict(d, d2, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.md_update_from_dict(d, d2, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.md_update_from_dict(d, d2, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_md_update_from_seq() -> None:
    d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})
    lst = [("foo", "bar"), ("k", "v2")]

    d = d1.copy()
    testcapi.md_update_from_seq(d, lst, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.md_update_from_seq(d, lst, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.md_update_from_seq(d, lst, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_md_type() -> None:
    assert testcapi.md_type() is MultiDict


def test_md_version() -> None:
    d = MultiDict()  # type: ignore[var-annotated]
    assert testcapi.md_version(d) != 0


def test_md_proxy_new() -> None:
    mdp = testcapi.md_proxy_new(MultiDict({"a": 1}))
    assert mdp.getone("a") == 1


def test_md_proxy_contains() -> None:
    d: MultiDictProxyStr = MultiDictProxy(MultiDict([("key", "one")]))
    assert testcapi.md_proxy_contains(d, "key")


def test_md_proxy_getall() -> None:
    d: MultiDictStr = MultiDict()
    d.add("key1", "val1")
    d.add("key2", "val2")
    d.add("key1", "val3")
    proxy = MultiDictProxy(d)

    ret = testcapi.md_proxy_getall(proxy, "key1")
    assert (["val1", "val3"], True) == ret


def test_md_proxy_get_all_miss() -> None:
    d = MultiDictProxy(MultiDict([("key", "value1")], key="value2"))
    assert testcapi.md_proxy_getall(d, "x")[1] is False


def test_md_proxy_getone() -> None:
    m = MultiDict(key="val1")
    m.add("key", "val2")
    d: MultiDictProxyStr = MultiDictProxy(m)
    assert testcapi.md_proxy_getone(d, "key") == ("val1", True)


def test_md_proxy_getone_miss() -> None:
    d: MultiDictProxyStr = MultiDictProxy(MultiDict([("key", "value1")], key="value2"))
    assert testcapi.md_proxy_getone(d, "x")[1] is False


def test_md_proxy_type() -> None:
    assert testcapi.md_proxy_type() is MultiDictProxy


def test_istr_from_unicode() -> None:
    i = testcapi.istr_from_unicode("aBcD")
    assert isinstance(i, istr)
    assert i == "aBcD"


def test_istr_from_string() -> None:
    # bytes are used to represent char* in C...
    i = testcapi.istr_from_string(b"aBcD")
    assert isinstance(i, istr)
    assert i == "aBcD"


def test_istr_from_string_and_size() -> None:
    i = testcapi.istr_from_string_and_size(b"testingDO_NOT_SHOW", 7)
    assert isinstance(i, istr)
    assert i == "testing"


def test_istr_get_type() -> None:
    assert istr == testcapi.istr_get_type()


def test_ci_md_add() -> None:
    md: CIMultiDictStr = CIMultiDict()
    testcapi.ci_md_add(md, "key", "value")
    assert len(md) == 1
    assert list(md.items()) == [("key", "value")]


def test_ci_md_clear() -> None:
    previous = CIMultiDict([("key", "value")])
    md: CIMultiDictStr = previous.copy()
    testcapi.ci_md_clear(md)
    assert md != previous


def test_ci_md_contains() -> None:
    d = CIMultiDict([("key", "one")])
    assert testcapi.ci_md_contains(d, "key")
    testcapi.ci_md_del(d, "key")
    assert testcapi.ci_md_contains(d, "key") is False


def test_ci_md_del() -> None:
    d = CIMultiDict([("key", "one"), ("key", "two")], foo="bar")
    assert list(d.keys()) == ["key", "key", "foo"]

    testcapi.ci_md_del(d, "key")
    assert d == {"foo": "bar"}
    assert list(d.items()) == [("foo", "bar")]

    with pytest.raises(KeyError, match="key"):
        testcapi.ci_md_del(d, "key")


def test_ci_md_get_all() -> None:
    d: CIMultiDictStr = CIMultiDict()
    d.add("key1", "val1")
    d.add("key2", "val2")
    d.add("key1", "val3")
    ret = testcapi.ci_md_getall(d, "key1")
    assert (["val1", "val3"], True) == ret


def test_ci_md_get_all_miss() -> None:
    d = CIMultiDict([("key", "value1")], key="value2")
    assert testcapi.ci_md_getall(d, "x")[1] is False


def test_ci_md_getone() -> None:
    d: CIMultiDictStr = CIMultiDict(key="val1")
    d.add("key", "val2")
    assert testcapi.ci_md_getone(d, "key") == ("val1", True)


def test_ci_md_getone_miss() -> None:
    d: CIMultiDictStr = CIMultiDict([("key", "value1")], key="value2")
    assert testcapi.ci_md_getone(d, "x")[1] is False


def test_ci_md_new() -> None:
    md = testcapi.ci_md_new(0)
    assert isinstance(md, CIMultiDict)
    assert len(md) == 0


def test_ci_md_popall() -> None:
    d: CIMultiDictStr = CIMultiDict()

    d.add("key1", "val1")
    d.add("key2", "val2")
    d.add("key1", "val3")
    ret = testcapi.ci_md_popall(d, "key1")
    assert (["val1", "val3"], True) == ret
    assert {"key2": "val2"} == d


def test_ci_md_popall_key_miss() -> None:
    d: CIMultiDictStr = CIMultiDict()
    assert testcapi.ci_md_popall(d, "x")[1] is False


def test_ci_md_popone() -> None:
    d: CIMultiDictStr = CIMultiDict()
    d.add("key", "val1")
    d.add("key2", "val2")
    d.add("key", "val3")

    assert ("val1", True) == testcapi.ci_md_popone(d, "key")
    assert [("key2", "val2"), ("key", "val3")] == list(d.items())


def test_ci_md_popone_miss() -> None:
    d: CIMultiDictStr = CIMultiDict(other="val")
    assert testcapi.ci_md_popone(d, "x")[1] is False


def test_ci_md_popitem() -> None:
    d: CIMultiDictStr = CIMultiDict()
    d.add("key", "val1")
    d.add("key", "val2")

    assert ("key", "val2") == testcapi.ci_md_popitem(d)
    assert len(d) == 1
    assert [("key", "val1")] == list(d.items())


def test_ci_md_replace() -> None:
    d: CIMultiDictStr = CIMultiDict()
    d.add("key", "val1")
    testcapi.ci_md_replace(d, "key", "val2")
    assert "val2" == d["key"]
    testcapi.ci_md_replace(d, "key", "val3")
    assert "val3" == d["key"]


def test_ci_md_setdefault() -> None:
    md: CIMultiDictStr = CIMultiDict([("key", "one"), ("key", "two")], foo="bar")
    assert ("one", True) == testcapi.ci_md_setdefault(md, "key", "three")
    assert (None, False) == testcapi.ci_md_setdefault(md, "otherkey", "three")
    assert "otherkey" in md
    assert "three" == md["otherkey"]


def test_ci_md_update_from_md() -> None:
    d1: CIMultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})
    d2: CIMultiDictStr = CIMultiDict({"foo": "bar", "k": "v2"})

    d = d1.copy()
    testcapi.ci_md_update_from_md(d, d2, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.ci_md_update_from_md(d, d2, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.ci_md_update_from_md(d, d2, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_ci_md_update_from_ci_mdproxy() -> None:
    d1: MultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})
    d2: MultiDictProxyStr = CIMultiDictProxy(CIMultiDict({"foo": "bar", "k": "v2"}))

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.md_update_from_md(d, d2, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_ci_md_update_from_dict() -> None:
    d1: CIMultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})
    d2 = {"foo": "bar", "k": "v2"}

    d = d1.copy()
    testcapi.ci_md_update_from_dict(d, d2, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.ci_md_update_from_dict(d, d2, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.ci_md_update_from_dict(d, d2, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_ci_md_update_from_seq() -> None:
    d1: CIMultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})
    lst = [("foo", "bar"), ("k", "v2")]

    d = d1.copy()
    testcapi.ci_md_update_from_seq(d, lst, 0)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(
        d.items()
    )

    d = d1.copy()
    testcapi.ci_md_update_from_seq(d, lst, 1)
    assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())

    d = d1.copy()
    testcapi.ci_md_update_from_seq(d, lst, 2)
    assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())


def test_ci_md_type() -> None:
    assert testcapi.ci_md_type() is CIMultiDict


def test_ci_md_version() -> None:
    d = CIMultiDict()  # type: ignore[var-annotated]
    assert testcapi.ci_md_version(d) != 0


def test_ci_md_proxy_new() -> None:
    mdp = testcapi.ci_md_proxy_new(CIMultiDict({"a": 1}))
    assert mdp.getone("a") == 1


def test_ci_md_proxy_contains() -> None:
    d: CIMultiDictProxyStr = CIMultiDictProxy(CIMultiDict([("key", "one")]))
    assert testcapi.ci_md_proxy_contains(d, "key")


def test_ci_md_proxy_getall() -> None:
    d: CIMultiDictStr = CIMultiDict()
    d.add("key1", "val1")
    d.add("key2", "val2")
    d.add("key1", "val3")
    proxy = CIMultiDictProxy(d)

    ret = testcapi.ci_md_proxy_getall(proxy, "key1")
    assert (["val1", "val3"], True) == ret


def test_ci_md_proxy_get_all_miss() -> None:
    d = CIMultiDictProxy(CIMultiDict([("key", "value1")], key="value2"))
    assert testcapi.ci_md_proxy_getall(d, "x")[1] is False


def test_ci_md_proxy_getone() -> None:
    m = CIMultiDict(key="val1")
    m.add("key", "val2")
    d: CIMultiDictProxyStr = CIMultiDictProxy(m)
    assert testcapi.ci_md_proxy_getone(d, "key") == ("val1", True)


def test_ci_md_proxy_getone_miss() -> None:
    d: CIMultiDictProxyStr = CIMultiDictProxy(
        CIMultiDict([("key", "value1")], key="value2")
    )
    assert testcapi.ci_md_proxy_getone(d, "x")[1] is False


def test_ci_md_proxy_type() -> None:
    assert testcapi.ci_md_proxy_type() is CIMultiDictProxy


def test_md_iter_new() -> None:
    md = MultiDict([("key", "value1")], key="value2")
    it = testcapi.md_iter_new(md.copy())
    for k, _ in it:
        assert k in md


def test_md_iter_next() -> None:
    md = MultiDict([("key", "value1")], key="value2")
    it = testcapi.md_iter_new(md.copy())
    assert testcapi.md_iter_next(it) == ("key", "value1", True)
    assert testcapi.md_iter_next(it) == ("key", "value2", True)
    assert testcapi.md_iter_next(it) == (None, None, False)

1	import pytest	2✔
2
3	from multidict import MultiDict, MultiDictProxy, istr, CIMultiDict, CIMultiDictProxy	2✔
4
5	pytest.importorskip("multidict._multidict")	×
6	# We need this extension since there was no other decent way to
7	# compile it as a seperate project. the only logical solution was
8	# to inject it directly.
NEW 9	testcapi = pytest.importorskip("multidict._testcapi")	×
10
11	pytestmark = pytest.mark.capi	2✔
12
13	MultiDictStr = MultiDict[str]	2✔
14	MultiDictProxyStr = MultiDictProxy[str]	2✔
15
16	CIMultiDictStr = CIMultiDict[str]	2✔
17	CIMultiDictProxyStr = MultiDictProxy[str]	2✔
18
19
20	def test_md_add() -> None:	2✔
21	md: MultiDictStr = MultiDict()	2✔
22	testcapi.md_add(md, "key", "value")	×
23	assert len(md) == 1	2✔
24	assert list(md.items()) == [("key", "value")]	2✔
25
26
27	def test_md_clear() -> None:	2✔
28	previous = MultiDict([("key", "value")])	2✔
29	md: MultiDictStr = previous.copy()	2✔
30	testcapi.md_clear(md)	×
31	assert md != previous	2✔
32
33
34	def test_md_contains() -> None:	2✔
35	d = MultiDict([("key", "one")])	2✔
36	assert testcapi.md_contains(d, "key")	×
37	testcapi.md_del(d, "key")	×
38	assert testcapi.md_contains(d, "key") is False	×
39
40
41	def test_md_del() -> None:	2✔
42	d = MultiDict([("key", "one"), ("key", "two")], foo="bar")	2✔
43	assert list(d.keys()) == ["key", "key", "foo"]	2✔
44
45	testcapi.md_del(d, "key")	×
46	assert d == {"foo": "bar"}	2✔
47	assert list(d.items()) == [("foo", "bar")]	2✔
48
49	with pytest.raises(KeyError, match="key"):	2✔
50	testcapi.md_del(d, "key")	×
51
52
53	def test_md_get_all() -> None:	2✔
54	d: MultiDictStr = MultiDict()	2✔
55	d.add("key1", "val1")	2✔
56	d.add("key2", "val2")	2✔
57	d.add("key1", "val3")	2✔
58	ret = testcapi.md_getall(d, "key1")	×
59	assert (["val1", "val3"], True) == ret	×
60
61
62	def test_md_get_all_miss() -> None:	2✔
63	d = MultiDict([("key", "value1")], key="value2")	2✔
64	assert testcapi.md_getall(d, "x")[1] is False	×
65
66
67	def test_md_getone() -> None:	2✔
68	d: MultiDictStr = MultiDict(key="val1")	2✔
69	d.add("key", "val2")	2✔
70	assert testcapi.md_getone(d, "key") == ("val1", True)	×
71
72
73	def test_md_getone_miss() -> None:	2✔
74	d: MultiDictStr = MultiDict([("key", "value1")], key="value2")	2✔
75	assert testcapi.md_getone(d, "x")[1] is False	×
76
77
78	def test_md_new() -> None:	2✔
79	md = testcapi.md_new(0)	×
NEW 80	assert isinstance(md, MultiDict)	×
81	assert len(md) == 0	2✔
82
83
84	def test_md_popall() -> None:	2✔
85	d: MultiDictStr = MultiDict()	2✔
86
87	d.add("key1", "val1")	2✔
88	d.add("key2", "val2")	2✔
89	d.add("key1", "val3")	2✔
90	ret = testcapi.md_popall(d, "key1")	×
91	assert (["val1", "val3"], True) == ret	×
92	assert {"key2": "val2"} == d	2✔
93
94
95	def test_md_popall_key_miss() -> None:	2✔
96	d: MultiDictStr = MultiDict()	2✔
97	assert testcapi.md_popall(d, "x")[1] is False	×
98
99
100	def test_md_popone() -> None:	2✔
101	d: MultiDictStr = MultiDict()	2✔
102	d.add("key", "val1")	2✔
103	d.add("key2", "val2")	2✔
104	d.add("key", "val3")	2✔
105
106	assert ("val1", True) == testcapi.md_popone(d, "key")	×
107	assert [("key2", "val2"), ("key", "val3")] == list(d.items())	2✔
108
109
110	def test_md_popone_miss() -> None:	2✔
111	d: MultiDictStr = MultiDict(other="val")	2✔
112	assert testcapi.md_popone(d, "x")[1] is False	×
113
114
115	def test_md_popitem() -> None:	2✔
116	d: MultiDictStr = MultiDict()	2✔
117	d.add("key", "val1")	2✔
118	d.add("key", "val2")	2✔
119
120	assert ("key", "val2") == testcapi.md_popitem(d)	×
121	assert len(d) == 1	2✔
122	assert [("key", "val1")] == list(d.items())	2✔
123
124
125	def test_md_replace() -> None:	2✔
126	d: MultiDictStr = MultiDict()	2✔
127	d.add("key", "val1")	2✔
128	testcapi.md_replace(d, "key", "val2")	×
129	assert "val2" == d["key"]	2✔
130	testcapi.md_replace(d, "key", "val3")	×
131	assert "val3" == d["key"]	2✔
132
133
134	def test_md_setdefault() -> None:	2✔
135	md: MultiDictStr = MultiDict([("key", "one"), ("key", "two")], foo="bar")	2✔
136	assert ("one", True) == testcapi.md_setdefault(md, "key", "three")	×
137	assert (None, False) == testcapi.md_setdefault(md, "otherkey", "three")	×
138	assert "otherkey" in md	2✔
139	assert "three" == md["otherkey"]	2✔
140
141
142	def test_md_update_from_md() -> None:	2✔
143	d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})	2✔
144	d2: MultiDictStr = MultiDict({"foo": "bar", "k": "v2"})	2✔
145
146	d = d1.copy()	2✔
NEW 147	testcapi.md_update_from_md(d, d2, 0)	×
148	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
149	d.items()	2✔
150	)
151
152
153	def test_md_update_from_mdproxy() -> None:	2✔
154	d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})	2✔
155	d2: MultiDictProxyStr = MultiDictProxy(MultiDict({"foo": "bar", "k": "v2"}))	2✔
156
157	d = d1.copy()	2✔
158	testcapi.md_update_from_md(d, d2, 0)	×
159	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
160	d.items()	2✔
161	)
162
163	d = d1.copy()	2✔
164	testcapi.md_update_from_md(d, d2, 1)	×
165	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
166
167	d = d1.copy()	2✔
168	testcapi.md_update_from_md(d, d2, 2)	×
169	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
170
171
172	def test_md_update_from_dict() -> None:	2✔
173	d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})	2✔
174	d2 = {"foo": "bar", "k": "v2"}	2✔
175
176	d = d1.copy()	2✔
177	testcapi.md_update_from_dict(d, d2, 0)	×
178	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
179	d.items()	2✔
180	)
181
182	d = d1.copy()	2✔
183	testcapi.md_update_from_dict(d, d2, 1)	×
184	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
185
186	d = d1.copy()	2✔
187	testcapi.md_update_from_dict(d, d2, 2)	×
188	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
189
190
191	def test_md_update_from_seq() -> None:	2✔
192	d1: MultiDictStr = MultiDict({"key": "val1", "k": "v1"})	2✔
193	lst = [("foo", "bar"), ("k", "v2")]	2✔
194
195	d = d1.copy()	2✔
196	testcapi.md_update_from_seq(d, lst, 0)	×
197	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
198	d.items()	2✔
199	)
200
201	d = d1.copy()	2✔
202	testcapi.md_update_from_seq(d, lst, 1)	×
203	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
204
205	d = d1.copy()	2✔
206	testcapi.md_update_from_seq(d, lst, 2)	×
207	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
208
209
210	def test_md_type() -> None:	2✔
NEW 211	assert testcapi.md_type() is MultiDict	×
212
213
214	def test_md_version() -> None:	2✔
215	d = MultiDict() # type: ignore[var-annotated]	2✔
216	assert testcapi.md_version(d) != 0	×
217
218
219	def test_md_proxy_new() -> None:	2✔
NEW 220	mdp = testcapi.md_proxy_new(MultiDict({"a": 1}))	×
NEW 221	assert mdp.getone("a") == 1	×
222
223
224	def test_md_proxy_contains() -> None:	2✔
225	d: MultiDictProxyStr = MultiDictProxy(MultiDict([("key", "one")]))	2✔
NEW 226	assert testcapi.md_proxy_contains(d, "key")	×
227
228
229	def test_md_proxy_getall() -> None:	2✔
230	d: MultiDictStr = MultiDict()	2✔
231	d.add("key1", "val1")	2✔
232	d.add("key2", "val2")	2✔
233	d.add("key1", "val3")	2✔
234	proxy = MultiDictProxy(d)	2✔
235
NEW 236	ret = testcapi.md_proxy_getall(proxy, "key1")	×
NEW 237	assert (["val1", "val3"], True) == ret	×
238
239
240	def test_md_proxy_get_all_miss() -> None:	2✔
241	d = MultiDictProxy(MultiDict([("key", "value1")], key="value2"))	2✔
NEW 242	assert testcapi.md_proxy_getall(d, "x")[1] is False	×
243
244
245	def test_md_proxy_getone() -> None:	2✔
246	m = MultiDict(key="val1")	2✔
247	m.add("key", "val2")	2✔
248	d: MultiDictProxyStr = MultiDictProxy(m)	2✔
NEW 249	assert testcapi.md_proxy_getone(d, "key") == ("val1", True)	×
250
251
252	def test_md_proxy_getone_miss() -> None:	2✔
253	d: MultiDictProxyStr = MultiDictProxy(MultiDict([("key", "value1")], key="value2"))	2✔
NEW 254	assert testcapi.md_proxy_getone(d, "x")[1] is False	×
255
256
257	def test_md_proxy_type() -> None:	2✔
NEW 258	assert testcapi.md_proxy_type() is MultiDictProxy	×
259
260
261	def test_istr_from_unicode() -> None:	2✔
NEW 262	i = testcapi.istr_from_unicode("aBcD")	×
NEW 263	assert isinstance(i, istr)	×
264	assert i == "aBcD"	2✔
265
266
267	def test_istr_from_string() -> None:	2✔
268	# bytes are used to represent char* in C...
NEW 269	i = testcapi.istr_from_string(b"aBcD")	×
NEW 270	assert isinstance(i, istr)	×
271	assert i == "aBcD"	2✔
272
273
274	def test_istr_from_string_and_size() -> None:	2✔
NEW 275	i = testcapi.istr_from_string_and_size(b"testingDO_NOT_SHOW", 7)	×
NEW 276	assert isinstance(i, istr)	×
277	assert i == "testing"	2✔
278
279
280	def test_istr_get_type() -> None:	2✔
NEW 281	assert istr == testcapi.istr_get_type()	×
282
283
284	def test_ci_md_add() -> None:	2✔
285	md: CIMultiDictStr = CIMultiDict()	2✔
NEW 286	testcapi.ci_md_add(md, "key", "value")	×
287	assert len(md) == 1	2✔
288	assert list(md.items()) == [("key", "value")]	2✔
289
290
291	def test_ci_md_clear() -> None:	2✔
292	previous = CIMultiDict([("key", "value")])	2✔
293	md: CIMultiDictStr = previous.copy()	2✔
NEW 294	testcapi.ci_md_clear(md)	×
295	assert md != previous	2✔
296
297
298	def test_ci_md_contains() -> None:	2✔
299	d = CIMultiDict([("key", "one")])	2✔
NEW 300	assert testcapi.ci_md_contains(d, "key")	×
NEW 301	testcapi.ci_md_del(d, "key")	×
NEW 302	assert testcapi.ci_md_contains(d, "key") is False	×
303
304
305	def test_ci_md_del() -> None:	2✔
306	d = CIMultiDict([("key", "one"), ("key", "two")], foo="bar")	2✔
307	assert list(d.keys()) == ["key", "key", "foo"]	2✔
308
NEW 309	testcapi.ci_md_del(d, "key")	×
310	assert d == {"foo": "bar"}	2✔
311	assert list(d.items()) == [("foo", "bar")]	2✔
312
313	with pytest.raises(KeyError, match="key"):	2✔
NEW 314	testcapi.ci_md_del(d, "key")	×
315
316
317	def test_ci_md_get_all() -> None:	2✔
318	d: CIMultiDictStr = CIMultiDict()	2✔
319	d.add("key1", "val1")	2✔
320	d.add("key2", "val2")	2✔
321	d.add("key1", "val3")	2✔
NEW 322	ret = testcapi.ci_md_getall(d, "key1")	×
NEW 323	assert (["val1", "val3"], True) == ret	×
324
325
326	def test_ci_md_get_all_miss() -> None:	2✔
327	d = CIMultiDict([("key", "value1")], key="value2")	2✔
NEW 328	assert testcapi.ci_md_getall(d, "x")[1] is False	×
329
330
331	def test_ci_md_getone() -> None:	2✔
332	d: CIMultiDictStr = CIMultiDict(key="val1")	2✔
333	d.add("key", "val2")	2✔
NEW 334	assert testcapi.ci_md_getone(d, "key") == ("val1", True)	×
335
336
337	def test_ci_md_getone_miss() -> None:	2✔
338	d: CIMultiDictStr = CIMultiDict([("key", "value1")], key="value2")	2✔
NEW 339	assert testcapi.ci_md_getone(d, "x")[1] is False	×
340
341
342	def test_ci_md_new() -> None:	2✔
NEW 343	md = testcapi.ci_md_new(0)	×
NEW 344	assert isinstance(md, CIMultiDict)	×
345	assert len(md) == 0	2✔
346
347
348	def test_ci_md_popall() -> None:	2✔
349	d: CIMultiDictStr = CIMultiDict()	2✔
350
351	d.add("key1", "val1")	2✔
352	d.add("key2", "val2")	2✔
353	d.add("key1", "val3")	2✔
NEW 354	ret = testcapi.ci_md_popall(d, "key1")	×
NEW 355	assert (["val1", "val3"], True) == ret	×
356	assert {"key2": "val2"} == d	2✔
357
358
359	def test_ci_md_popall_key_miss() -> None:	2✔
360	d: CIMultiDictStr = CIMultiDict()	2✔
NEW 361	assert testcapi.ci_md_popall(d, "x")[1] is False	×
362
363
364	def test_ci_md_popone() -> None:	2✔
365	d: CIMultiDictStr = CIMultiDict()	2✔
366	d.add("key", "val1")	2✔
367	d.add("key2", "val2")	2✔
368	d.add("key", "val3")	2✔
369
NEW 370	assert ("val1", True) == testcapi.ci_md_popone(d, "key")	×
371	assert [("key2", "val2"), ("key", "val3")] == list(d.items())	2✔
372
373
374	def test_ci_md_popone_miss() -> None:	2✔
375	d: CIMultiDictStr = CIMultiDict(other="val")	2✔
NEW 376	assert testcapi.ci_md_popone(d, "x")[1] is False	×
377
378
379	def test_ci_md_popitem() -> None:	2✔
380	d: CIMultiDictStr = CIMultiDict()	2✔
381	d.add("key", "val1")	2✔
382	d.add("key", "val2")	2✔
383
NEW 384	assert ("key", "val2") == testcapi.ci_md_popitem(d)	×
385	assert len(d) == 1	2✔
386	assert [("key", "val1")] == list(d.items())	2✔
387
388
389	def test_ci_md_replace() -> None:	2✔
390	d: CIMultiDictStr = CIMultiDict()	2✔
391	d.add("key", "val1")	2✔
NEW 392	testcapi.ci_md_replace(d, "key", "val2")	×
393	assert "val2" == d["key"]	2✔
NEW 394	testcapi.ci_md_replace(d, "key", "val3")	×
395	assert "val3" == d["key"]	2✔
396
397
398	def test_ci_md_setdefault() -> None:	2✔
399	md: CIMultiDictStr = CIMultiDict([("key", "one"), ("key", "two")], foo="bar")	2✔
NEW 400	assert ("one", True) == testcapi.ci_md_setdefault(md, "key", "three")	×
NEW 401	assert (None, False) == testcapi.ci_md_setdefault(md, "otherkey", "three")	×
402	assert "otherkey" in md	2✔
403	assert "three" == md["otherkey"]	2✔
404
405
406	def test_ci_md_update_from_md() -> None:	2✔
407	d1: CIMultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})	2✔
408	d2: CIMultiDictStr = CIMultiDict({"foo": "bar", "k": "v2"})	2✔
409
410	d = d1.copy()	2✔
NEW 411	testcapi.ci_md_update_from_md(d, d2, 0)	×
412	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
413	d.items()	2✔
414	)
415
416	d = d1.copy()	2✔
NEW 417	testcapi.ci_md_update_from_md(d, d2, 1)	×
418	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
419
420	d = d1.copy()	2✔
NEW 421	testcapi.ci_md_update_from_md(d, d2, 2)	×
422	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
423
424
425	def test_ci_md_update_from_ci_mdproxy() -> None:	2✔
426	d1: MultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})	2✔
427	d2: MultiDictProxyStr = CIMultiDictProxy(CIMultiDict({"foo": "bar", "k": "v2"}))	2✔
428
429	d = d1.copy()	2✔
NEW 430	testcapi.md_update_from_md(d, d2, 0)	×
431	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
432	d.items()	2✔
433	)
434
435	d = d1.copy()	2✔
NEW 436	testcapi.md_update_from_md(d, d2, 1)	×
437	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
438
439	d = d1.copy()	2✔
NEW 440	testcapi.md_update_from_md(d, d2, 2)	×
441	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
442
443
444	def test_ci_md_update_from_dict() -> None:	2✔
445	d1: CIMultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})	2✔
446	d2 = {"foo": "bar", "k": "v2"}	2✔
447
448	d = d1.copy()	2✔
NEW 449	testcapi.ci_md_update_from_dict(d, d2, 0)	×
450	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
451	d.items()	2✔
452	)
453
454	d = d1.copy()	2✔
NEW 455	testcapi.ci_md_update_from_dict(d, d2, 1)	×
456	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
457
458	d = d1.copy()	2✔
NEW 459	testcapi.ci_md_update_from_dict(d, d2, 2)	×
460	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
461
462
463	def test_ci_md_update_from_seq() -> None:	2✔
464	d1: CIMultiDictStr = CIMultiDict({"key": "val1", "k": "v1"})	2✔
465	lst = [("foo", "bar"), ("k", "v2")]	2✔
466
467	d = d1.copy()	2✔
NEW 468	testcapi.ci_md_update_from_seq(d, lst, 0)	×
469	assert [("key", "val1"), ("k", "v1"), ("foo", "bar"), ("k", "v2")] == list(	2✔
470	d.items()	2✔
471	)
472
473	d = d1.copy()	2✔
NEW 474	testcapi.ci_md_update_from_seq(d, lst, 1)	×
475	assert [("key", "val1"), ("k", "v2"), ("foo", "bar")] == list(d.items())	2✔
476
477	d = d1.copy()	2✔
NEW 478	testcapi.ci_md_update_from_seq(d, lst, 2)	×
479	assert [("key", "val1"), ("k", "v1"), ("foo", "bar")] == list(d.items())	2✔
480
481
482	def test_ci_md_type() -> None:	2✔
NEW 483	assert testcapi.ci_md_type() is CIMultiDict	×
484
485
486	def test_ci_md_version() -> None:	2✔
487	d = CIMultiDict() # type: ignore[var-annotated]	2✔
NEW 488	assert testcapi.ci_md_version(d) != 0	×
489
490
491	def test_ci_md_proxy_new() -> None:	2✔
NEW 492	mdp = testcapi.ci_md_proxy_new(CIMultiDict({"a": 1}))	×
NEW 493	assert mdp.getone("a") == 1	×
494
495
496	def test_ci_md_proxy_contains() -> None:	2✔
497	d: CIMultiDictProxyStr = CIMultiDictProxy(CIMultiDict([("key", "one")]))	2✔
NEW 498	assert testcapi.ci_md_proxy_contains(d, "key")	×
499
500
501	def test_ci_md_proxy_getall() -> None:	2✔
502	d: CIMultiDictStr = CIMultiDict()	2✔
503	d.add("key1", "val1")	2✔
504	d.add("key2", "val2")	2✔
505	d.add("key1", "val3")	2✔
506	proxy = CIMultiDictProxy(d)	2✔
507
NEW 508	ret = testcapi.ci_md_proxy_getall(proxy, "key1")	×
NEW 509	assert (["val1", "val3"], True) == ret	×
510
511
512	def test_ci_md_proxy_get_all_miss() -> None:	2✔
513	d = CIMultiDictProxy(CIMultiDict([("key", "value1")], key="value2"))	2✔
NEW 514	assert testcapi.ci_md_proxy_getall(d, "x")[1] is False	×
515
516
517	def test_ci_md_proxy_getone() -> None:	2✔
518	m = CIMultiDict(key="val1")	2✔
519	m.add("key", "val2")	2✔
520	d: CIMultiDictProxyStr = CIMultiDictProxy(m)	2✔
NEW 521	assert testcapi.ci_md_proxy_getone(d, "key") == ("val1", True)	×
522
523
524	def test_ci_md_proxy_getone_miss() -> None:	2✔
525	d: CIMultiDictProxyStr = CIMultiDictProxy(	2✔
526	CIMultiDict([("key", "value1")], key="value2")	2✔
527	)
NEW 528	assert testcapi.ci_md_proxy_getone(d, "x")[1] is False	×
529
530
531	def test_ci_md_proxy_type() -> None:	2✔
NEW 532	assert testcapi.ci_md_proxy_type() is CIMultiDictProxy	×
533
534
535	def test_md_iter_new() -> None:	2✔
536	md = MultiDict([("key", "value1")], key="value2")	2✔
NEW 537	it = testcapi.md_iter_new(md.copy())	×
NEW 538	for k, _ in it:	×
NEW 539	assert k in md	×
540
541
542	def test_md_iter_next() -> None:	2✔
543	md = MultiDict([("key", "value1")], key="value2")	2✔
NEW 544	it = testcapi.md_iter_new(md.copy())	×
NEW 545	assert testcapi.md_iter_next(it) == ("key", "value1", True)	×
NEW 546	assert testcapi.md_iter_next(it) == ("key", "value2", True)	×
NEW 547	assert testcapi.md_iter_next(it) == (None, None, False)	×

aio-libs / multidict / 18199243591

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous