Skip some tests

Author: ilevkivskyi

mypy/test/data.py

@@ -604,6 +604,12 @@ def pytest_addoption(parser: Any) -> None:
         default=False,
         help="Update test data to reflect actual output (supported only for certain tests)",
     )
+    group.addoption(
+        "--mypy-num-workers",
+        type=int,
+        default=0,
+        help="Run tests using multiple worker processes for each test case",
+    )
     group.addoption(
         "--save-failures-to",
         default=None,

mypy/test/helpers.py

@@ -365,6 +365,8 @@ def parse_options(
 
     if testcase.config.getoption("--mypy-verbose"):
         options.verbosity = testcase.config.getoption("--mypy-verbose")
+    if testcase.config.getoption("--mypy-num-workers"):
+        options.num_workers = testcase.config.getoption("--mypy-num-workers")
 
     return options
 

mypy/test/testcheck.py

@@ -137,7 +137,9 @@ def run_case_once(
         if options.num_workers:
             options.fixed_format_cache = True
             if testcase.output_files:
-                raise pytest.skip("Reports are not supported in parallel mode yet")
+                raise pytest.skip("Reports are not supported in parallel mode")
+            if testcase.name.endswith("_no_parallel"):
+                raise pytest.skip("Test not supported in parallel mode yet")
 
         # Enable some options automatically based on test file name.
         if "columns" in testcase.file:

test-data/unit/check-classes.test

@@ -7683,7 +7683,7 @@ class Child(metaclass=M, thing=0):
     pass
 [builtins fixtures/object_with_init_subclass.pyi]
 
-[case testTooManyArgsForObject]
+[case testTooManyArgsForObject_no_parallel]
 class A(thing=5):
     pass
 [out]
@@ -8498,7 +8498,7 @@ def identity_wrapper(func: FuncT) -> FuncT:
 def foo(self: Any) -> str:
     return ""
 
-[case testParentClassWithTypeAliasAndSubclassWithMethod]
+[case testParentClassWithTypeAliasAndSubclassWithMethod_no_parallel]
 from typing import Any, Callable, TypeVar
 
 class Parent:

test-data/unit/check-flags.test

@@ -2477,7 +2477,7 @@ cb(lambda x: a)  # OK
 fn = lambda x: a
 cb(fn)
 
-[case testShowErrorCodeLinks]
+[case testShowErrorCodeLinks_no_parallel]
 # flags: --show-error-codes --show-error-code-links
 
 x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]

test-data/unit/check-functions.test

@@ -1224,24 +1224,20 @@ import b
 from d import dec
 @dec
 def f(x: int) -> None: pass
-b.g(1) # E
+b.g(1)  # E: Argument 1 to "g" has incompatible type "int"; expected "str"
 
 [file b.py]
 import a
 from d import dec
 @dec
 def g(x: str) -> None: pass
-a.f('')
+a.f('')  # E: Argument 1 to "f" has incompatible type "str"; expected "int"
 
 [file d.py]
 from typing import TypeVar
 T = TypeVar('T')
 def dec(f: T) -> T: return f
 
-[out]
-tmp/b.py:5: error: Argument 1 to "f" has incompatible type "str"; expected "int"
-tmp/a.py:5: error: Argument 1 to "g" has incompatible type "int"; expected "str"
-
 [case testDecoratorWithNoAnnotationInImportCycle]
 import a
 
@@ -1270,23 +1266,19 @@ import b
 from d import dec
 @dec
 def f(x: int) -> str: pass
-b.g(1)()
+b.g(1)()  # E: "str" not callable
 
 [file b.py]
 import a
 from d import dec
 @dec
 def g(x: int) -> str: pass
-a.f(1)()
+a.f(1)()  # E: "str" not callable
 
 [file d.py]
 from typing import Callable
 def dec(f: Callable[[int], str]) -> Callable[[int], str]: return f
 
-[out]
-tmp/b.py:5: error: "str" not callable
-tmp/a.py:5: error: "str" not callable
-
 [case testDecoratorWithCallAndFixedReturnTypeInImportCycle]
 import a
 
@@ -1295,50 +1287,40 @@ import b
 from d import dec
 @dec()
 def f(x: int) -> str: pass
-b.g(1)()
+b.g(1)()  # E: "str" not callable
 
 [file b.py]
 import a
 from d import dec
 @dec()
 def g(x: int) -> str: pass
-a.f(1)()
+a.f(1)()  # E: "str" not callable
 
 [file d.py]
 from typing import Callable
 def dec() -> Callable[[Callable[[int], str]], Callable[[int], str]]: pass
 
-[out]
-tmp/b.py:5: error: "str" not callable
-tmp/a.py:5: error: "str" not callable
-
 [case testDecoratorWithCallAndFixedReturnTypeInImportCycleAndDecoratorArgs]
 import a
 
 [file a.py]
 import b
 from d import dec
-@dec(1)
+@dec(1)  # E: Argument 1 to "dec" has incompatible type "int"; expected "str"
 def f(x: int) -> str: pass
-b.g(1)()
+b.g(1)()  # E: "str" not callable
 
 [file b.py]
 import a
 from d import dec
-@dec(1)
+@dec(1)  # E: Argument 1 to "dec" has incompatible type "int"; expected "str"
 def g(x: int) -> str: pass
-a.f(1)()
+a.f(1)()  # E: "str" not callable
 
 [file d.py]
 from typing import Callable
 def dec(x: str) -> Callable[[Callable[[int], str]], Callable[[int], str]]: pass
 
-[out]
-tmp/b.py:3: error: Argument 1 to "dec" has incompatible type "int"; expected "str"
-tmp/b.py:5: error: "str" not callable
-tmp/a.py:3: error: Argument 1 to "dec" has incompatible type "int"; expected "str"
-tmp/a.py:5: error: "str" not callable
-
 [case testUndefinedDecoratorInImportCycle]
 # cmd: mypy -m foo.base
 [file foo/__init__.py]

test-data/unit/check-ignore.test

@@ -198,7 +198,7 @@ bar(Child())
 [out]
 main:19: error: Argument 1 to "bar" has incompatible type "Child"; expected "Base[str, str]"
 
-[case testTypeIgnoreLineNumberWithinFile]
+[case testTypeIgnoreLineNumberWithinFile_no_parallel]
 import m
 pass # type: ignore
 m.f(kw=1)

test-data/unit/check-incremental.test

@@ -6902,7 +6902,7 @@ class TheClass:
 tmp/a.py:3: note: Revealed type is "def (value: builtins.object) -> lib.TheClass.pyenum@6"
 
 
-[case testIncrementalFunctoolsPartial]
+[case testIncrementalFunctoolsPartial_no_parallel]
 import a
 
 [file a.py]

test-data/unit/check-inference.test

@@ -1747,7 +1747,7 @@ def f(blocks: Any): # E: Name "Any" is not defined \
     to_process = list(blocks)
 [builtins fixtures/list.pyi]
 
-[case testSpecialCaseEmptyListInitialization2]
+[case testSpecialCaseEmptyListInitialization2_no_parallel]
 def f(blocks: object):
     to_process = []
     to_process = list(blocks) # E: No overload variant of "list" matches argument type "object" \
@@ -3644,17 +3644,14 @@ class A:
 import a
 [file a.py]
 import b
-reveal_type(b.B.x)
+reveal_type(b.B.x)  # N: Revealed type is "builtins.int"
 class A:
     x = 42
 [file b.py]
 import a
-reveal_type(a.A.x)
+reveal_type(a.A.x)  # N: Revealed type is "builtins.int"
 class B:
     x = 42
-[out]
-tmp/b.py:2: note: Revealed type is "builtins.int"
-tmp/a.py:2: note: Revealed type is "builtins.int"
 
 [case testUnionTypeCallableInference]
 from typing import Callable, Type, TypeVar, Union

test-data/unit/check-kwargs.test

@@ -464,7 +464,7 @@ class A:
             pass
 A.B(x=1)  # E: Unexpected keyword argument "x" for "B"
 
-[case testUnexpectedMethodKwargFromOtherModule]
+[case testUnexpectedMethodKwargFromOtherModule_no_parallel]
 import m
 m.A(x=1)
 [file m.py]