Current File : //usr/lib/python3/dist-packages/mypyc/test-data/commandline.test
-- Test cases for invoking mypyc on the command line
--
-- These are slow -- do not add test cases unless you have a very good reason to do so.
[case testCompileMypyc]
# cmd: a.py b.py p/__init__.py p/q.py
import os.path
import p
import p.q
import a
import b
print('<main>', b.g(a.A()))
try:
a.f('')
except TypeError:
pass
else:
assert False
for x in [a, b, p, p.q]:
assert os.path.splitext(x.__file__)[1] != '.py'
[file z.py]
[file a.py]
import b
import c
from p import s
from typing import NamedTuple
print('<a>', ord('A') == 65) # Test full builtins
class A:
def __init__(self) -> None:
self.x = 4
def f(x: int) -> b.B:
return b.B(x)
class B:
def __init__(self, x: int, y: str) -> None:
self.x = x
print('<a>', f(5).x)
print('<c>', c.foo())
assert s.bar(10) == 20
class NT(NamedTuple):
x: int
print(NT(2))
[file b.py]
import a
import p.q
class B:
def __init__(self, x: int) -> None:
self.x = x
def g(z: 'a.A') -> int:
return p.q.foo(z.x)
print('<b>', 'here')
[file c.py]
def foo() -> int:
return 10
[file p/__init__.py]
[file p/q.py]
import p.r
def foo(x: int) -> int:
return x*p.r.foo(x)
[file p/r.py]
def foo(x: int) -> int:
return x
[file p/s.py]
def bar(x: int) -> int:
return x*2
[out]
<b> here
<a> True
<a> 5
<c> 10
NT(x=2)
<main> 16
-- This test is here so we can turn it on when we get nervous about
-- this case, but is disabled for speed reasons.
[case testCompileMypycOne-skip]
# cmd: a.py
import os.path
import a
assert os.path.splitext(a.__file__)[1] != '.py'
assert a.f(10) == 100
[file a.py]
def f(x: int) -> int:
return x*x
[case testErrorOutput]
# cmd: test.py
[file test.py]
from typing import List, Any, AsyncIterable
from typing_extensions import Final
from mypy_extensions import trait, mypyc_attr
from functools import singledispatch
def busted(b: bool) -> None:
for i in range(1, 10, 0): # E: range() step can't be zero
try:
if i == 5:
break # E: break inside try/finally block is unimplemented
elif i == 4:
continue # E: continue inside try/finally block is unimplemented
finally:
print('oops')
print(sum([1,2,3]))
x = [1,2]
class Foo:
a, b = (10, 20) # E: Only assignment to variables is supported in class bodies
x[0] = 10 # E: Only assignment to variables is supported in class bodies
lol = 20
l = [10] # W: Unsupported default attribute value
c = d = 50 # E: Multiple assignment in class bodies not supported
if 1+1 == 2: # E: Unsupported statement in class body
x = 10
Foo.lol = 50 # E: Only class variables defined as ClassVar can be assigned to
def decorator(x: Any) -> Any:
return x
class NeverMetaclass(type): # E: Inheriting from most builtin types is unimplemented
pass
class Concrete1:
pass
@trait
class PureTrait:
pass
@trait
class Trait1(Concrete1):
pass
class Concrete2:
pass
@trait
class Trait2(Concrete2):
pass
@decorator
class NonExt(Concrete1): # E: Non-extension classes may not inherit from extension classes
pass
class Nope(Trait1, Concrete2): # E: Non-trait bases must appear first in parent list # E: Non-trait MRO must be linear
pass
@decorator
class NonExt2:
@property # E: Property setters not supported in non-extension classes
def test(self) -> int:
pass
@test.setter
def test(self, x: int) -> None:
pass
iterator_warning = (i+1 for i in range(10)) # W: Treating generator comprehension as list
# But we don't want warnings for these cases:
tup = tuple(i+1 for i in range(10))
a_str = " ".join(str(i) for i in range(10))
wtvr = next(i for i in range(10) if i == 5)
d1 = {1: 2}
# Make sure we can produce an error when we hit the awful None case
def f(l: List[object]) -> None:
x = None # E: Local variable "x" has inferred type None; add an annotation
for i in l:
if x is None:
x = i
@mypyc_attr(allow_interpreted_subclasses=True)
class AllowInterp1(Concrete1): # E: Base class "test.Concrete1" does not allow interpreted subclasses
pass
@mypyc_attr(allow_interpreted_subclasses=True)
class AllowInterp2(PureTrait): # E: Base class "test.PureTrait" does not allow interpreted subclasses
pass
async def async_for(xs: AsyncIterable[int]) -> None:
async for x in xs: # E: async for is unimplemented
print(x)
[x async for x in xs] # E: async comprehensions are unimplemented
(x async for x in xs) # E: async comprehensions are unimplemented # W: Treating generator comprehension as list
{x async for x in xs} # E: async comprehensions are unimplemented
{x: x async for x in xs} # E: async comprehensions are unimplemented
class async_ctx:
async def __aenter__(self) -> int: pass
async def __aexit__(self, x, y, z) -> None: pass
async def async_with() -> None:
async with async_ctx() as x: # E: async with is unimplemented
print(x)
async def async_generators() -> AsyncIterable[int]:
yield 1 # E: async generators are unimplemented
@singledispatch
def a(arg) -> None:
pass
@decorator # E: Calling decorator after registering function not supported
@a.register
def g(arg: int) -> None:
pass
@a.register
@decorator
def h(arg: str) -> None:
pass
@decorator
@decorator # E: Calling decorator after registering function not supported
@a.register
def i(arg: Foo) -> None:
pass
Mini Shell