mypy-dev 1.9.0.dev0__py3-none-any.whl

mypyc/test-data/run-dunders.test

@@ -0,0 +1,945 @@
+# Test cases for (some) dunder methods (compile and run)
+
+[case testDundersMisc]
+# Legacy test case for dunders (don't add more here)
+
+from typing import Any
+class Item:
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __eq__(self, rhs: object) -> bool:
+        return isinstance(rhs, Item) and self.value == rhs.value
+
+    def __lt__(self, x: 'Item') -> bool:
+        return self.value < x.value
+
+class Subclass1(Item):
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+class NonBoxedThing:
+    def __getitem__(self, index: Item) -> Item:
+        return Item("2 * " + index.value + " + 1")
+
+class BoxedThing:
+    def __getitem__(self, index: int) -> int:
+        return 2 * index + 1
+
+class Subclass2(BoxedThing):
+    pass
+
+class UsesNotImplemented:
+    def __eq__(self, b: object) -> bool:
+        return NotImplemented
+
+def index_into(x : Any, y : Any) -> Any:
+    return x[y]
+
+def internal_index_into() -> None:
+    x = BoxedThing()
+    print (x[3])
+    y = NonBoxedThing()
+    z = Item("3")
+    print(y[z].value)
+
+def is_truthy(x: Item) -> bool:
+    return True if x else False
+
+[file driver.py]
+from native import *
+x = BoxedThing()
+y = 3
+print(x[y], index_into(x, y))
+
+x = Subclass2()
+y = 3
+print(x[y], index_into(x, y))
+
+z = NonBoxedThing()
+w = Item("3")
+print(z[w].value, index_into(z, w).value)
+
+i1 = Item('lolol')
+i2 = Item('lol' + 'ol')
+i3 = Item('xyzzy')
+assert hash(i1) == hash(i2)
+
+assert i1 == i2
+assert not i1 != i2
+assert not i1 == i3
+assert i1 != i3
+assert i2 < i3
+assert not i1 < i2
+assert i1 == Subclass1('lolol')
+
+assert is_truthy(Item(''))
+assert is_truthy(Item('a'))
+assert not is_truthy(Subclass1(''))
+assert is_truthy(Subclass1('a'))
+
+assert UsesNotImplemented() != object()
+
+internal_index_into()
+[out]
+7 7
+7 7
+2 * 3 + 1 2 * 3 + 1
+7
+2 * 3 + 1
+
+[case testDundersContainer]
+# Sequence/mapping dunder methods
+
+from typing import Any
+
+class Seq:
+    def __init__(self) -> None:
+        self.key = 0
+        self.value = 0
+
+    def __len__(self) -> int:
+        return 5
+
+    def __setitem__(self, key: int, value: int) -> None:
+        self.key = key
+        self.value = value
+
+    def __contains__(self, x: int) -> bool:
+        return x == 3
+
+    def __delitem__(self, key: int) -> None:
+        self.key = key
+
+class Plain: pass
+
+def any_seq() -> Any:
+    """Return Any-typed Seq."""
+    return Seq()
+
+def any_plain() -> Any:
+    """Return Any-typed Seq."""
+    return Plain()
+
+def test_len() -> None:
+    assert len(any_seq()) == 5
+    assert len(Seq()) == 5
+
+def test_len_error() -> None:
+    try:
+        len(any_plain())
+    except TypeError:
+        pass
+    else:
+        assert False
+
+def test_set_item() -> None:
+    s = any_seq()
+    s[44] = 66
+    assert s.key == 44 and s.value == 66
+    ss = Seq()
+    ss[33] = 55
+    assert ss.key == 33 and ss.value == 55
+
+def test_contains() -> None:
+    assert 3 in any_seq()
+    assert 4 not in any_seq()
+    assert 2 not in any_seq()
+    assert 3 in Seq()
+    assert 4 not in Seq()
+    assert 2 not in Seq()
+
+def test_delitem() -> None:
+    s = any_seq()
+    del s[55]
+    assert s.key == 55
+
+class SeqAny:
+    def __contains__(self, x: Any) -> Any:
+        return x == 3
+
+    def __setitem__(self, x: Any, y: Any) -> Any:
+        self.x = x
+        return 'x'
+
+def test_contains_any() -> None:
+    assert (3 in SeqAny()) is True
+    assert (2 in SeqAny()) is False
+    assert (3 not in SeqAny()) is False
+    assert (2 not in SeqAny()) is True
+    s = SeqAny()  # type: Any
+    assert (3 in s) is True
+    assert (2 in s) is False
+    assert (3 not in s) is False
+    assert (2 not in s) is True
+
+def test_set_item_any() -> None:
+    s = SeqAny()
+    s[4] = 6
+    assert s.x == 4
+    ss = SeqAny()  # type: Any
+    ss[5] = 7
+    assert ss.x == 5
+
+class SeqError:
+    def __setitem__(self, key: int, value: int) -> None:
+        raise RuntimeError()
+
+    def __contains__(self, x: int) -> bool:
+        raise RuntimeError()
+
+    def __len__(self):
+        return -5
+
+def any_seq_error() -> Any:
+    return SeqError()
+
+def test_set_item_error_propagate() -> None:
+    s = any_seq_error()
+    try:
+        s[44] = 66
+    except RuntimeError:
+        pass
+    else:
+        assert False
+
+def test_contains_error_propagate() -> None:
+    s = any_seq_error()
+    try:
+        3 in s
+    except RuntimeError:
+        pass
+    else:
+        assert False
+
+def test_negative_len() -> None:
+    try:
+        len(SeqError())
+    except ValueError:
+        pass
+    else:
+        assert False
+
+class DelItemNoSetItem:
+    def __delitem__(self, x: int) -> None:
+        self.key = x
+
+def test_del_item_with_no_set_item() -> None:
+    o = DelItemNoSetItem()
+    del o[22]
+    assert o.key == 22
+    a = o  # type: Any
+    del a[12]
+    assert a.key == 12
+    try:
+        a[1] = 2
+    except TypeError as e:
+        assert str(e) == "'DelItemNoSetItem' object does not support item assignment"
+    else:
+        assert False
+
+class SetItemOverride(dict):
+    # Only override __setitem__, __delitem__ comes from dict
+
+    def __setitem__(self, x: int, y: int) -> None:
+        self.key = x
+        self.value = y
+
+def test_set_item_override() -> None:
+    o = SetItemOverride({'x': 12, 'y': 13})
+    o[2] = 3
+    assert o.key == 2 and o.value == 3
+    a = o  # type: Any
+    o[4] = 5
+    assert o.key == 4 and o.value == 5
+    assert o['x'] == 12
+    assert o['y'] == 13
+    del o['x']
+    assert 'x' not in o and 'y' in o
+    del a['y']
+    assert 'y' not in a and 'x' not in a
+
+class DelItemOverride(dict):
+    # Only override __delitem__, __setitem__ comes from dict
+
+    def __delitem__(self, x: int) -> None:
+        self.key = x
+
+def test_del_item_override() -> None:
+    o = DelItemOverride()
+    del o[2]
+    assert o.key == 2
+    a = o  # type: Any
+    del o[5]
+    assert o.key == 5
+    o['x'] = 12
+    assert o['x'] == 12
+    a['y'] = 13
+    assert a['y'] == 13
+
+class SetItemOverrideNative(Seq):
+    def __setitem__(self, key: int, value: int) -> None:
+        self.key = key + 1
+        self.value = value + 1
+
+def test_native_set_item_override() -> None:
+    o = SetItemOverrideNative()
+    o[1] = 4
+    assert o.key == 2 and o.value == 5
+    del o[6]
+    assert o.key == 6
+    a = o  # type: Any
+    a[10] = 12
+    assert a.key == 11 and a.value == 13
+    del a[16]
+    assert a.key == 16
+
+class DelItemOverrideNative(Seq):
+    def __delitem__(self, key: int) -> None:
+        self.key = key + 2
+
+def test_native_del_item_override() -> None:
+    o = DelItemOverrideNative()
+    o[1] = 4
+    assert o.key == 1 and o.value == 4
+    del o[6]
+    assert o.key == 8
+    a = o  # type: Any
+    a[10] = 12
+    assert a.key == 10 and a.value == 12
+    del a[16]
+    assert a.key == 18
+
+[case testDundersNumber]
+from typing import Any
+
+class C:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+    def __neg__(self) -> int:
+        return self.x + 1
+
+    def __invert__(self) -> int:
+        return self.x + 2
+
+    def __int__(self) -> int:
+        return self.x + 3
+
+    def __float__(self) -> float:
+        return float(self.x + 4)
+
+    def __pos__(self) -> int:
+        return self.x + 5
+
+    def __abs__(self) -> int:
+        return abs(self.x) + 6
+
+
+def test_unary_dunders_generic() -> None:
+    a: Any = C(10)
+
+    assert -a == 11
+    assert ~a == 12
+    assert int(a) == 13
+    assert float(a) == 14.0
+    assert +a == 15
+    assert abs(a) == 16
+
+def test_unary_dunders_native() -> None:
+    c = C(10)
+
+    assert -c == 11
+    assert ~c == 12
+    assert int(c) == 13
+    assert float(c) == 14.0
+    assert +c == 15
+    assert abs(c) == 16
+
+[case testDundersBinarySimple]
+from typing import Any
+
+class C:
+    def __init__(self) -> None:
+        self.x = 5
+
+    def __add__(self, y: int) -> int:
+        return self.x + y
+
+    def __sub__(self, y: int) -> int:
+        return self.x - y
+
+    def __mul__(self, y: int) -> int:
+        return self.x * y
+
+    def __mod__(self, y: int) -> int:
+        return self.x % y
+
+    def __lshift__(self, y: int) -> int:
+        return self.x << y
+
+    def __rshift__(self, y: int) -> int:
+        return self.x >> y
+
+    def __and__(self, y: int) -> int:
+        return self.x & y
+
+    def __or__(self, y: int) -> int:
+        return self.x | y
+
+    def __xor__(self, y: int) -> int:
+        return self.x ^ y
+
+    def __matmul__(self, y: int) -> int:
+        return self.x + y + 10
+
+    def __truediv__(self, y: int) -> int:
+        return self.x + y + 20
+
+    def __floordiv__(self, y: int) -> int:
+        return self.x + y + 30
+
+    def __divmod__(self, y: int) -> int:
+        return self.x + y + 40
+
+    def __pow__(self, y: int) -> int:
+        return self.x + y + 50
+
+def test_generic() -> None:
+    a: Any = C()
+    assert a + 3 == 8
+    assert a - 3 == 2
+    assert a * 5 == 25
+    assert a % 2 == 1
+    assert a << 4 == 80
+    assert a >> 0 == 5
+    assert a >> 1 == 2
+    assert a & 1 == 1
+    assert a | 3 == 7
+    assert a ^ 3 == 6
+    assert a @ 3 == 18
+    assert a / 2 == 27
+    assert a // 2 == 37
+    assert divmod(a, 2) == 47
+    assert a ** 2 == 57
+
+def test_native() -> None:
+    c = C()
+    assert c + 3 == 8
+    assert c - 3 == 2
+    assert divmod(c, 3) == 48
+    assert c ** 3 == 58
+
+def test_error() -> None:
+    a: Any = C()
+    try:
+        a + 'x'
+    except TypeError as e:
+        assert str(e) == "unsupported operand type(s) for +: 'C' and 'str'"
+    else:
+        assert False
+    try:
+        a - 'x'
+    except TypeError as e:
+        assert str(e) == "unsupported operand type(s) for -: 'C' and 'str'"
+    else:
+        assert False
+    try:
+        a ** 'x'
+    except TypeError as e:
+        assert str(e) == "unsupported operand type(s) for **: 'C' and 'str'"
+    else:
+        assert False
+
+[case testDundersBinaryReverse]
+from typing import Any
+
+class C:
+    def __init__(self) -> None:
+        self.x = 5
+
+    def __add__(self, y: int) -> int:
+        return self.x + y
+
+    def __radd__(self, y: int) -> int:
+        return self.x + y + 1
+
+    def __sub__(self, y: int) -> int:
+        return self.x - y
+
+    def __rsub__(self, y: int) -> int:
+        return self.x - y - 1
+
+    def __pow__(self, y: int) -> int:
+        return self.x**y
+
+    def __rpow__(self, y: int) -> int:
+        return self.x**y + 1
+
+def test_generic() -> None:
+    a: Any = C()
+    assert a + 3 == 8
+    assert 4 + a == 10
+    assert a - 3 == 2
+    assert 4 - a == 0
+    assert a**3 == 125
+    assert 4**a == 626
+
+def test_native() -> None:
+    c = C()
+    assert c + 3 == 8
+    assert 4 + c == 10
+    assert c - 3 == 2
+    assert 4 - c == 0
+    assert c**3 == 125
+    assert 4**c == 626
+
+def test_errors() -> None:
+    a: Any = C()
+    try:
+        a + 'x'
+    except TypeError as e:
+        assert str(e) == "unsupported operand type(s) for +: 'C' and 'str'"
+    else:
+        assert False
+    try:
+        a - 'x'
+    except TypeError as e:
+        assert str(e) == "unsupported operand type(s) for -: 'C' and 'str'"
+    else:
+        assert False
+    try:
+        'x' + a
+    except TypeError as e:
+        assert str(e) in ('can only concatenate str (not "C") to str',
+                          'must be str, not C')
+    else:
+        assert False
+    try:
+        'x' ** a
+    except TypeError as e:
+        assert str(e) == "unsupported operand type(s) for ** or pow(): 'str' and 'C'"
+    else:
+        assert False
+
+
+class F:
+    def __add__(self, x: int) -> int:
+        return 5
+
+    def __pow__(self, x: int) -> int:
+        return -5
+
+class G:
+    def __add__(self, x: int) -> int:
+        return 33
+
+    def __pow__(self, x: int) -> int:
+        return -33
+
+    def __radd__(self, x: F) -> int:
+        return 6
+
+    def __rpow__(self, x: F) -> int:
+        return -6
+
+def test_type_mismatch_fall_back_to_reverse() -> None:
+    assert F() + G() == 6
+    assert F()**G() == -6
+
+[case testDundersBinaryNotImplemented]
+from typing import Any, Union
+from testutil import assertRaises
+
+class C:
+    def __init__(self, v: int) -> None:
+        self.v = v
+
+    def __add__(self, y: int) -> Union[int, Any]:
+        if y == 1:
+            return self.v
+        return NotImplemented
+
+def test_any_add() -> None:
+    a: Any = C(4)
+    assert a + 1 == 4
+    try:
+        a + 2
+    except TypeError:
+        pass
+    else:
+        assert False
+
+class D:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+    def __add__(self, e: E) -> Union[int, Any]:
+        if e.x == 1:
+            return 2
+        return NotImplemented
+
+class E:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+    def __radd__(self, d: D) -> Union[int, Any]:
+        if d.x == 3:
+            return 4
+        return NotImplemented
+
+def test_any_radd() -> None:
+    d1: Any = D(1)
+    d3: Any = D(3)
+    e1: Any = E(1)
+    e3: Any = E(3)
+    assert d1 + e1 == 2
+    assert d3 + e1 == 2
+    assert d3 + e3 == 4
+
+class F:
+    def __init__(self, v):
+        self.v = v
+
+    def __add__(self, x):
+        if isinstance(x, int):
+            return self.v + x
+        return NotImplemented
+
+class G:
+    def __radd__(self, x):
+        if isinstance(x, F):
+            return x.v + 1
+        if isinstance(x, str):
+            return 'a'
+        return NotImplemented
+
+def test_unannotated_add() -> None:
+    o = F(4)
+    assert o + 5 == 9
+    with assertRaises(TypeError, "unsupported operand type(s) for +: 'F' and 'str'"):
+        o + 'x'
+
+def test_unannotated_add_and_radd_1() -> None:
+    o = F(4)
+    assert o + G() == 5
+
+def test_unannotated_radd() -> None:
+    assert 'x' + G() == 'a'
+    with assertRaises(TypeError, "unsupported operand type(s) for +: 'int' and 'G'"):
+        1 + G()
+
+class H:
+    def __add__(self, x):
+        if isinstance(x, int):
+            return x + 1
+        return NotImplemented
+
+    def __radd__(self, x):
+        if isinstance(x, str):
+            return 22
+        return NotImplemented
+
+def test_unannotated_add_and_radd_2() -> None:
+    h = H()
+    assert h + 5 == 6
+    assert 'x' + h == 22
+    with assertRaises(TypeError, "unsupported operand type(s) for +: 'int' and 'H'"):
+        1 + h
+
+# TODO: Inheritance
+
+[case testDifferentReverseDunders]
+class C:
+    # __radd__ and __rsub__ are tested elsewhere
+
+    def __rmul__(self, x):
+        return 1
+
+    def __rtruediv__(self, x):
+        return 2
+
+    def __rmod__(self, x):
+        return 3
+
+    def __rfloordiv__(self, x):
+        return 4
+
+    def __rlshift__(self, x):
+        return 5
+
+    def __rrshift__(self, x):
+        return 6
+
+    def __rand__(self, x):
+        return 7
+
+    def __ror__(self, x):
+        return 8
+
+    def __rxor__(self, x):
+        return 9
+
+    def __rmatmul__(self, x):
+        return 10
+
+def test_reverse_dunders() -> None:
+    x = 0
+    c = C()
+    assert x * c == 1
+    assert x / c == 2
+    assert x % c == 3
+    assert x // c == 4
+    assert x << c == 5
+    assert x >> c == 6
+    assert x & c == 7
+    assert x | c == 8
+    assert x ^ c == 9
+    assert x @ c == 10
+
+[case testDundersInplace]
+from typing import Any
+from testutil import assertRaises
+
+class C:
+    def __init__(self) -> None:
+        self.x = 5
+
+    def __iadd__(self, y: int) -> C:
+        self.x += y
+        return self
+
+    def __isub__(self, y: int) -> C:
+        self.x -= y
+        return self
+
+    def __imul__(self, y: int) -> C:
+        self.x *= y
+        return self
+
+    def __imod__(self, y: int) -> C:
+        self.x %= y
+        return self
+
+    def __itruediv__(self, y: int) -> C:
+        self.x += y + 10
+        return self
+
+    def __ifloordiv__(self, y: int) -> C:
+        self.x += y + 20
+        return self
+
+    def __ilshift__(self, y: int) -> C:
+        self.x <<= y
+        return self
+
+    def __irshift__(self, y: int) -> C:
+        self.x >>= y
+        return self
+
+    def __iand__(self, y: int) -> C:
+        self.x &= y
+        return self
+
+    def __ior__(self, y: int) -> C:
+        self.x |= y
+        return self
+
+    def __ixor__(self, y: int) -> C:
+        self.x ^= y
+        return self
+
+    def __imatmul__(self, y: int) -> C:
+        self.x += y + 5
+        return self
+
+    def __ipow__(self, y: int, __mod_throwaway: None = None) -> C:
+        self.x **= y
+        return self
+
+def test_generic_1() -> None:
+    c: Any = C()
+    c += 3
+    assert c.x == 8
+    c -= 5
+    assert c.x == 3
+    c *= 3
+    assert c.x == 9
+    c %= 4
+    assert c.x == 1
+    c /= 5
+    assert c.x == 16
+    c //= 4
+    assert c.x == 40
+    c **= 2
+    assert c.x == 1600
+
+def test_generic_2() -> None:
+    c: Any = C()
+    c <<= 4
+    assert c.x == 80
+    c >>= 3
+    assert c.x == 10
+    c &= 3
+    assert c.x == 2
+    c |= 6
+    assert c.x == 6
+    c ^= 12
+    assert c.x == 10
+    c @= 3
+    assert c.x == 18
+
+def test_native() -> None:
+    c = C()
+    c += 3
+    assert c.x == 8
+    c -= 5
+    assert c.x == 3
+    c *= 3
+    assert c.x == 9
+    c **= 2
+    assert c.x == 81
+
+def test_error() -> None:
+    c: Any = C()
+    with assertRaises(TypeError, "int object expected; got str"):
+        c += 'x'
+
+class BadInplaceAdd:
+    def __init__(self):
+        self.x = 0
+
+    def __iadd__(self, x):
+        self.x += x
+
+def test_in_place_operator_returns_none() -> None:
+    o = BadInplaceAdd()
+    with assertRaises(TypeError, "native.BadInplaceAdd object expected; got None"):
+        o += 5
+
+[case testDunderMinMax]
+class SomeItem:
+    def __init__(self, val: int) -> None:
+        self.val = val
+
+    def __lt__(self, x: 'SomeItem') -> bool:
+        return self.val < x.val
+
+    def __gt__(self, x: 'SomeItem') -> bool:
+        return self.val > x.val
+
+class AnotherItem:
+    def __init__(self, val: str) -> None:
+        self.val = val
+
+    def __lt__(self, x: 'AnotherItem') -> bool:
+        return True
+
+    def __gt__(self, x: 'AnotherItem') -> bool:
+        return True
+
+def test_dunder_min() -> None:
+    x = SomeItem(5)
+    y = SomeItem(10)
+    z = SomeItem(15)
+    assert min(x, y).val == 5
+    assert min(y, z).val == 10
+    assert max(x, y).val == 10
+    assert max(y, z).val == 15
+    x2 = AnotherItem('xxx')
+    y2 = AnotherItem('yyy')
+    z2 = AnotherItem('zzz')
+    assert min(x2, y2).val == 'yyy'
+    assert min(y2, x2).val == 'xxx'
+    assert max(x2, y2).val == 'yyy'
+    assert max(y2, x2).val == 'xxx'
+    assert min(y2, z2).val == 'zzz'
+    assert max(x2, z2).val == 'zzz'
+
+
+[case testDundersPowerSpecial]
+import sys
+from typing import Any, Optional
+from testutil import assertRaises
+
+class Forward:
+    def __pow__(self, exp: int, mod: Optional[int] = None) -> int:
+        if mod is None:
+            return 2**exp
+        else:
+            return 2**exp % mod
+
+class ForwardModRequired:
+    def __pow__(self, exp: int, mod: int) -> int:
+        return 2**exp % mod
+
+class ForwardNotImplemented:
+    def __pow__(self, exp: int, mod: Optional[object] = None) -> Any:
+        return NotImplemented
+
+class Reverse:
+    def __rpow__(self, exp: int) -> int:
+        return 2**exp + 1
+
+class Both:
+    def __pow__(self, exp: int, mod: Optional[int] = None) -> int:
+        if mod is None:
+            return 2**exp
+        else:
+            return 2**exp % mod
+
+    def __rpow__(self, exp: int) -> int:
+        return 2**exp + 1
+
+class Child(ForwardNotImplemented):
+    def __rpow__(self, exp: object) -> int:
+        return 50
+
+class Inplace:
+    value = 2
+
+    def __ipow__(self, exp: int, mod: Optional[int] = None) -> "Inplace":
+        self.value **= exp - (mod or 0)
+        return self
+
+def test_native() -> None:
+    f = Forward()
+    assert f**3 == 8
+    assert pow(f, 3) == 8
+    assert pow(f, 3, 3) == 2
+    assert pow(ForwardModRequired(), 3, 3) == 2
+    b = Both()
+    assert b**3 == 8
+    assert 3**b == 9
+    assert pow(b, 3) == 8
+    assert pow(b, 3, 3) == 2
+    i = Inplace()
+    i **= 2
+    assert i.value == 4
+
+def test_errors() -> None:
+    if sys.version_info[0] >= 3 and sys.version_info[1] >= 10:
+        op = "** or pow()"
+    else:
+        op = "pow()"
+
+    f = Forward()
+    with assertRaises(TypeError, f"unsupported operand type(s) for {op}: 'Forward', 'int', 'str'"):
+        pow(f, 3, "x")  # type: ignore
+    with assertRaises(TypeError, "unsupported operand type(s) for **: 'Forward' and 'str'"):
+        f**"x"  # type: ignore
+    r = Reverse()
+    with assertRaises(TypeError, "unsupported operand type(s) for ** or pow(): 'str' and 'Reverse'"):
+        "x"**r  # type: ignore
+    with assertRaises(TypeError, f"unsupported operand type(s) for {op}: 'int', 'Reverse', 'int'"):
+        # Ternary pow() does not fallback to __rpow__ if LHS's __pow__ returns NotImplemented.
+        pow(3, r, 3)  # type: ignore
+    with assertRaises(TypeError, f"unsupported operand type(s) for {op}: 'ForwardNotImplemented', 'Child', 'int'"):
+        # Ternary pow() does not try RHS's __rpow__ first when it's a subclass and redefines
+        # __rpow__ unlike other ops.
+        pow(ForwardNotImplemented(), Child(), 3)  # type: ignore
+    with assertRaises(TypeError, "unsupported operand type(s) for ** or pow(): 'ForwardModRequired' and 'int'"):
+        ForwardModRequired()**3  # type: ignore