jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/run-singledispatch.test

@@ -1,698 +0,0 @@
-# Test cases related to the functools.singledispatch decorator
-# Most of these tests are marked as xfails because mypyc doesn't support singledispatch yet
-# (These tests will be re-enabled when mypyc supports singledispatch)
-
-[case testSpecializedImplementationUsed]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-@fun.register
-def fun_specialized(arg: str) -> bool:
-    return True
-
-def test_specialize() -> None:
-    assert fun('a')
-    assert not fun(3)
-
-[case testSubclassesOfExpectedTypeUseSpecialized]
-from functools import singledispatch
-class A: pass
-class B(A): pass
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-@fun.register
-def fun_specialized(arg: A) -> bool:
-    return True
-
-def test_specialize() -> None:
-    assert fun(B())
-    assert fun(A())
-
-[case testSuperclassImplementationNotUsedWhenSubclassHasImplementation]
-from functools import singledispatch
-class A: pass
-class B(A): pass
-
-@singledispatch
-def fun(arg) -> bool:
-    # shouldn't be using this
-    assert False
-
-@fun.register
-def fun_specialized(arg: A) -> bool:
-    return False
-
-@fun.register
-def fun_specialized2(arg: B) -> bool:
-    return True
-
-def test_specialize() -> None:
-    assert fun(B())
-    assert not fun(A())
-
-[case testMultipleUnderscoreFunctionsIsntError]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> str:
-    return 'default'
-
-@fun.register
-def _(arg: str) -> str:
-    return 'str'
-
-@fun.register
-def _(arg: int) -> str:
-    return 'int'
-
-# extra function to make sure all 3 underscore functions aren't treated as one OverloadedFuncDef
-def a(b): pass
-
-@fun.register
-def _(arg: list) -> str:
-    return 'list'
-
-def test_singledispatch() -> None:
-    assert fun(0) == 'int'
-    assert fun('a') == 'str'
-    assert fun([1, 2]) == 'list'
-    assert fun({'a': 'b'}) == 'default'
-
-[case testCanRegisterCompiledClasses]
-from functools import singledispatch
-class A: pass
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-@fun.register
-def fun_specialized(arg: A) -> bool:
-    return True
-
-def test_singledispatch() -> None:
-    assert fun(A())
-    assert not fun(1)
-
-[case testTypeUsedAsArgumentToRegister]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-@fun.register(int)
-def fun_specialized(arg) -> bool:
-    return True
-
-def test_singledispatch() -> None:
-    assert fun(1)
-    assert not fun('a')
-
-[case testUseRegisterAsAFunction]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-def fun_specialized_impl(arg) -> bool:
-    return True
-
-fun.register(int, fun_specialized_impl)
-
-def test_singledispatch() -> None:
-    assert fun(0)
-    assert not fun('a')
-
-[case testRegisterDoesntChangeFunction]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-@fun.register(int)
-def fun_specialized(arg) -> bool:
-    return True
-
-def test_singledispatch() -> None:
-    assert fun_specialized('a')
-
-# TODO: turn this into a mypy error
-[case testNoneIsntATypeWhenUsedAsArgumentToRegister]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-try:
-    @fun.register
-    def fun_specialized(arg: None) -> bool:
-        return True
-except TypeError:
-    pass
-
-[case testRegisteringTheSameFunctionSeveralTimes]
-from functools import singledispatch
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-@fun.register(int)
-@fun.register(str)
-def fun_specialized(arg) -> bool:
-    return True
-
-def test_singledispatch() -> None:
-    assert fun(0)
-    assert fun('a')
-    assert not fun([1, 2])
-
-[case testTypeIsAnABC]
-from functools import singledispatch
-from collections.abc import Mapping
-
-@singledispatch
-def fun(arg) -> bool:
-    return False
-
-@fun.register
-def fun_specialized(arg: Mapping) -> bool:
-    return True
-
-def test_singledispatch() -> None:
-    assert not fun(1)
-    assert fun({'a': 'b'})
-
-[case testSingleDispatchMethod-xfail]
-from functools import singledispatchmethod
-class A:
-    @singledispatchmethod
-    def fun(self, arg) -> str:
-        return 'default'
-
-    @fun.register
-    def fun_int(self, arg: int) -> str:
-        return 'int'
-
-    @fun.register
-    def fun_str(self, arg: str) -> str:
-        return 'str'
-
-def test_singledispatchmethod() -> None:
-    x = A()
-    assert x.fun(5) == 'int'
-    assert x.fun('a') == 'str'
-    assert x.fun([1, 2]) == 'default'
-
-[case testSingleDispatchMethodWithOtherDecorator-xfail]
-from functools import singledispatchmethod
-class A:
-    @singledispatchmethod
-    @staticmethod
-    def fun(arg) -> str:
-        return 'default'
-
-    @fun.register
-    @staticmethod
-    def fun_int(arg: int) -> str:
-        return 'int'
-
-    @fun.register
-    @staticmethod
-    def fun_str(arg: str) -> str:
-        return 'str'
-
-def test_singledispatchmethod() -> None:
-    x = A()
-    assert x.fun(5) == 'int'
-    assert x.fun('a') == 'str'
-    assert x.fun([1, 2]) == 'default'
-
-[case testSingledispatchTreeSumAndEqual]
-from functools import singledispatch
-
-class Tree:
-    pass
-class Leaf(Tree):
-    pass
-class Node(Tree):
-    def __init__(self, value: int, left: Tree, right: Tree) -> None:
-        self.value = value
-        self.left = left
-        self.right = right
-
-@singledispatch
-def calc_sum(x: Tree) -> int:
-    raise TypeError('invalid type for x')
-
-@calc_sum.register
-def _(x: Leaf) -> int:
-    return 0
-
-@calc_sum.register
-def _(x: Node) -> int:
-    return x.value + calc_sum(x.left) + calc_sum(x.right)
-
-@singledispatch
-def equal(to_compare: Tree, known: Tree) -> bool:
-    raise TypeError('invalid type for x')
-
-@equal.register
-def _(to_compare: Leaf, known: Tree) -> bool:
-    return isinstance(known, Leaf)
-
-@equal.register
-def _(to_compare: Node, known: Tree) -> bool:
-    if isinstance(known, Node):
-        if to_compare.value != known.value:
-            return False
-        else:
-            return equal(to_compare.left, known.left) and equal(to_compare.right, known.right)
-    return False
-
-def build(n: int) -> Tree:
-    if n == 0:
-        return Leaf()
-    return Node(n, build(n - 1), build(n - 1))
-
-def test_sum_and_equal():
-    tree = build(5)
-    tree2 = build(5)
-    tree2.right.right.right.value = 10
-    assert calc_sum(tree) == 57
-    assert calc_sum(tree2) == 65
-    assert equal(tree, tree)
-    assert not equal(tree, tree2)
-    tree3 = build(4)
-    assert not equal(tree, tree3)
-
-[case testSimulateMypySingledispatch]
-from functools import singledispatch
-from mypy_extensions import trait
-from typing import Iterator, Union, TypeVar, Any, List, Type
-# based on use of singledispatch in stubtest.py
-class Error:
-    def __init__(self, msg: str) -> None:
-        self.msg = msg
-
-@trait
-class Node: pass
-
-class MypyFile(Node): pass
-class TypeInfo(Node): pass
-
-
-@trait
-class SymbolNode(Node): pass
-@trait
-class Expression(Node): pass
-class TypeVarLikeExpr(SymbolNode, Expression): pass
-class TypeVarExpr(TypeVarLikeExpr): pass
-class TypeAlias(SymbolNode): pass
-
-class Missing: pass
-MISSING = Missing()
-
-T = TypeVar("T")
-
-MaybeMissing = Union[T, Missing]
-
-@singledispatch
-def verify(stub: Node, a: MaybeMissing[Any], b: List[str]) -> Iterator[Error]:
-    yield Error('unknown node type')
-
-@verify.register(MypyFile)
-def verify_mypyfile(stub: MypyFile, a: MaybeMissing[int], b: List[str]) -> Iterator[Error]:
-    if isinstance(a, Missing):
-        yield Error("shouldn't be missing")
-        return
-    if not isinstance(a, int):
-        # this check should be unnecessary because of the type signature and the previous check,
-        # but stubtest.py has this check
-        yield Error("should be an int")
-        return
-    yield from verify(TypeInfo(), str, ['abc', 'def'])
-
-@verify.register(TypeInfo)
-def verify_typeinfo(stub: TypeInfo, a: MaybeMissing[Type[Any]], b: List[str]) -> Iterator[Error]:
-    yield Error('in TypeInfo')
-    yield Error('hello')
-
-@verify.register(TypeVarExpr)
-def verify_typevarexpr(stub: TypeVarExpr, a: MaybeMissing[Any], b: List[str]) -> Iterator[Error]:
-    if False:
-        yield None
-
-def verify_list(stub, a, b) -> List[str]:
-    """Helper function that converts iterator of errors to list of messages"""
-    return list(err.msg for err in verify(stub, a, b))
-
-def test_verify() -> None:
-    assert verify_list(TypeAlias(), 'a', ['a', 'b']) == ['unknown node type']
-    assert verify_list(MypyFile(), MISSING, ['a', 'b']) == ["shouldn't be missing"]
-    assert verify_list(MypyFile(), 5, ['a', 'b']) == ['in TypeInfo', 'hello']
-    assert verify_list(TypeInfo(), str, ['a', 'b']) == ['in TypeInfo', 'hello']
-    assert verify_list(TypeVarExpr(), 'a', ['x', 'y']) == []
-
-
-[case testArgsInRegisteredImplNamedDifferentlyFromMainFunction]
-from functools import singledispatch
-
-@singledispatch
-def f(a) -> bool:
-    return False
-
-@f.register
-def g(b: int) -> bool:
-    return True
-
-def test_singledispatch():
-    assert f(5)
-    assert not f('a')
-
-[case testKeywordArguments]
-from functools import singledispatch
-
-@singledispatch
-def f(arg, *, kwarg: int = 0) -> int:
-    return kwarg + 10
-
-@f.register
-def g(arg: int, *, kwarg: int = 5) -> int:
-    return kwarg - 10
-
-def test_keywords():
-    assert f('a') == 10
-    assert f('a', kwarg=3) == 13
-    assert f('a', kwarg=7) == 17
-
-    assert f(1) == -5
-    assert f(1, kwarg=4) == -6
-    assert f(1, kwarg=6) == -4
-
-[case testGeneratorAndMultipleTypesOfIterable]
-from functools import singledispatch
-from typing import *
-
-@singledispatch
-def f(arg: Any) -> Iterable[int]:
-    yield 1
-
-@f.register
-def g(arg: str) -> Iterable[int]:
-    return [0]
-
-def test_iterables():
-    assert f(1) != [1]
-    assert list(f(1)) == [1]
-    assert f('a') == [0]
-
-[case testRegisterUsedAtSameTimeAsOtherDecorators]
-from functools import singledispatch
-from typing import TypeVar
-
-class A: pass
-class B: pass
-
-T = TypeVar('T')
-
-def decorator(f: T) -> T:
-    return f
-
-@singledispatch
-def f(arg) -> int:
-    return 0
-
-@f.register
-@decorator
-def h(arg: str) -> int:
-    return 2
-
-def test_singledispatch():
-    assert f(1) == 0
-    assert f('a') == 2
-
-[case testDecoratorModifiesFunction]
-from functools import singledispatch
-from typing import Callable, Any
-
-class A: pass
-
-def decorator(f: Callable[[Any], int]) -> Callable[[Any], int]:
-    def wrapper(x) -> int:
-        return f(x) * 7
-    return wrapper
-
-@singledispatch
-def f(arg) -> int:
-    return 10
-
-@f.register
-@decorator
-def h(arg: str) -> int:
-    return 5
-
-
-def test_singledispatch():
-    assert f('a') == 35
-    assert f(A()) == 10
-
-[case testMoreSpecificTypeBeforeLessSpecificType]
-from functools import singledispatch
-class A: pass
-class B(A): pass
-
-@singledispatch
-def f(arg) -> str:
-    return 'default'
-
-@f.register
-def g(arg: B) -> str:
-    return 'b'
-
-@f.register
-def h(arg: A) -> str:
-    return 'a'
-
-def test_singledispatch():
-    assert f(B()) == 'b'
-    assert f(A()) == 'a'
-    assert f(5) == 'default'
-
-[case testMultipleRelatedClassesBeingRegistered]
-from functools import singledispatch
-
-class A: pass
-class B(A): pass
-class C(B): pass
-
-@singledispatch
-def f(arg) -> str: return 'default'
-
-@f.register
-def _(arg: A) -> str: return 'a'
-
-@f.register
-def _(arg: C) -> str: return 'c'
-
-@f.register
-def _(arg: B) -> str: return 'b'
-
-def test_singledispatch():
-    assert f(A()) == 'a'
-    assert f(B()) == 'b'
-    assert f(C()) == 'c'
-    assert f(1) == 'default'
-
-[case testRegisteredImplementationsInDifferentFiles]
-from other_a import f, A, B, C
-@f.register
-def a(arg: A) -> int:
-    return 2
-
-@f.register
-def _(arg: C) -> int:
-    return 3
-
-def test_singledispatch():
-    assert f(B()) == 1
-    assert f(A()) == 2
-    assert f(C()) == 3
-    assert f(1) == 0
-
-[file other_a.py]
-from functools import singledispatch
-
-class A: pass
-class B(A): pass
-class C(B): pass
-
-@singledispatch
-def f(arg) -> int:
-    return 0
-
-@f.register
-def g(arg: B) -> int:
-    return 1
-
-[case testOrderCanOnlyBeDeterminedFromMRONotIsinstanceChecks]
-from mypy_extensions import trait
-from functools import singledispatch
-
-@trait
-class A: pass
-@trait
-class B: pass
-class AB(A, B): pass
-class BA(B, A): pass
-
-@singledispatch
-def f(arg) -> str:
-    return "default"
-    pass
-
-@f.register
-def fa(arg: A) -> str:
-    return "a"
-
-@f.register
-def fb(arg: B) -> str:
-    return "b"
-
-def test_singledispatch():
-    assert f(AB()) == "a"
-    assert f(BA()) == "b"
-
-[case testCallingFunctionBeforeAllImplementationsRegistered]
-from functools import singledispatch
-
-class A: pass
-class B(A): pass
-
-@singledispatch
-def f(arg) -> str:
-    return 'default'
-
-assert f(A()) == 'default'
-assert f(B()) == 'default'
-assert f(1) == 'default'
-
-@f.register
-def g(arg: A) -> str:
-    return 'a'
-
-assert f(A()) == 'a'
-assert f(B()) == 'a'
-assert f(1) == 'default'
-
-@f.register
-def _(arg: B) -> str:
-    return 'b'
-
-assert f(A()) == 'a'
-assert f(B()) == 'b'
-assert f(1) == 'default'
-
-
-[case testDynamicallyRegisteringFunctionFromInterpretedCode]
-from functools import singledispatch
-
-class A: pass
-class B(A): pass
-class C(B): pass
-class D(C): pass
-
-@singledispatch
-def f(arg) -> str:
-    return "default"
-
-@f.register
-def _(arg: B) -> str:
-    return 'b'
-
-[file register_impl.py]
-from native import f, A, B, C
-
-@f.register(A)
-def a(arg) -> str:
-    return 'a'
-
-@f.register
-def c(arg: C) -> str:
-    return 'c'
-
-[file driver.py]
-from native import f, A, B, C
-from register_impl import a, c
-# We need a custom driver here because register_impl has to be run before we test this (so that the
-# additional implementations are registered)
-assert f(C()) == 'c'
-assert f(A()) == 'a'
-assert f(B()) == 'b'
-assert a(C()) == 'a'
-assert c(A()) == 'c'
-
-[case testMalformedDynamicRegisterCall]
-from functools import singledispatch
-
-@singledispatch
-def f(arg) -> None:
-    pass
-[file register.py]
-from native import f
-from testutil import assertRaises
-
-with assertRaises(TypeError, 'Invalid first argument to `register()`'):
-    @f.register
-    def _():
-        pass
-
-[file driver.py]
-import register
-
-[case testCacheClearedWhenNewFunctionRegistered]
-from functools import singledispatch
-
-@singledispatch
-def f(arg) -> str:
-    return 'default'
-
-[file register.py]
-from native import f
-class A: pass
-class B: pass
-class C: pass
-
-# annotated function
-assert f(A()) == 'default'
-@f.register
-def _(arg: A) -> str:
-    return 'a'
-assert f(A()) == 'a'
-
-# type passed as argument
-assert f(B()) == 'default'
-@f.register(B)
-def _(arg: B) -> str:
-    return 'b'
-assert f(B()) == 'b'
-
-# 2 argument form
-assert f(C()) == 'default'
-def c(arg) -> str:
-    return 'c'
-f.register(C, c)
-assert f(C()) == 'c'
-
-
-[file driver.py]
-import register