Split unittest stubs and add a few field (python#2973)

stdlib/3/unittest/case.pyi

@@ -0,0 +1,224 @@
+from typing import (
+    Any, AnyStr, Callable, Container, ContextManager, Dict, FrozenSet, Generic,
+    Iterable, List, NoReturn, Optional, overload, Pattern, Sequence, Set,
+    Tuple, Type, TypeVar, Union,
+)
+import logging
+import unittest.result
+from types import TracebackType
+
+
+_E = TypeVar('_E', bound=BaseException)
+_FT = TypeVar('_FT', bound=Callable[..., Any])
+
+
+def expectedFailure(func: _FT) -> _FT: ...
+def skip(reason: str) -> Callable[[_FT], _FT]: ...
+def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
+def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
+
+
+class SkipTest(Exception):
+    def __init__(self, reason: str) -> None: ...
+
+
+class TestCase:
+    failureException: Type[BaseException]
+    longMessage: bool
+    maxDiff: Optional[int]
+    # undocumented
+    _testMethodName: str
+    # undocumented
+    _testMethodDoc: str
+    def __init__(self, methodName: str = ...) -> None: ...
+    def setUp(self) -> None: ...
+    def tearDown(self) -> None: ...
+    @classmethod
+    def setUpClass(cls) -> None: ...
+    @classmethod
+    def tearDownClass(cls) -> None: ...
+    def run(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ...
+    def __call__(self, result: Optional[unittest.result.TestResult] = ...) -> Optional[unittest.result.TestResult]: ...
+    def skipTest(self, reason: Any) -> None: ...
+    def subTest(self, msg: Any = ..., **params: Any) -> ContextManager[None]: ...
+    def debug(self) -> None: ...
+    def _addSkip(
+        self, result: unittest.result.TestResult, test_case: unittest.case.TestCase, reason: str
+    ) -> None: ...
+    def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
+    def assertNotEqual(self, first: Any, second: Any,
+                       msg: Any = ...) -> None: ...
+    def assertTrue(self, expr: Any, msg: Any = ...) -> None: ...
+    def assertFalse(self, expr: Any, msg: Any = ...) -> None: ...
+    def assertIs(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
+    def assertIsNot(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
+    def assertIsNone(self, obj: Any, msg: Any = ...) -> None: ...
+    def assertIsNotNone(self, obj: Any, msg: Any = ...) -> None: ...
+    def assertIn(self, member: Any,
+                 container: Union[Iterable[Any], Container[Any]],
+                 msg: Any = ...) -> None: ...
+    def assertNotIn(self, member: Any,
+                    container: Union[Iterable[Any], Container[Any]],
+                    msg: Any = ...) -> None: ...
+    def assertIsInstance(self, obj: Any,
+                         cls: Union[type, Tuple[type, ...]],
+                         msg: Any = ...) -> None: ...
+    def assertNotIsInstance(self, obj: Any,
+                            cls: Union[type, Tuple[type, ...]],
+                            msg: Any = ...) -> None: ...
+    def assertGreater(self, a: Any, b: Any, msg: Any = ...) -> None: ...
+    def assertGreaterEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
+    def assertLess(self, a: Any, b: Any, msg: Any = ...) -> None: ...
+    def assertLessEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
+    @overload
+    def assertRaises(self,  # type: ignore
+                     expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+                     callable: Callable[..., Any],
+                     *args: Any, **kwargs: Any) -> None: ...
+    @overload
+    def assertRaises(self,
+                     expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
+                     msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+    @overload
+    def assertRaisesRegex(self,  # type: ignore
+                          expected_exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+                          expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+                          callable: Callable[..., Any],
+                          *args: Any, **kwargs: Any) -> None: ...
+    @overload
+    def assertRaisesRegex(self,
+                          expected_exception: Union[Type[_E], Tuple[Type[_E], ...]],
+                          expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+                          msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+    @overload
+    def assertWarns(self,  # type: ignore
+                    expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+                    callable: Callable[..., Any],
+                    *args: Any, **kwargs: Any) -> None: ...
+    @overload
+    def assertWarns(self,
+                    expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+                    msg: Any = ...) -> _AssertWarnsContext: ...
+    @overload
+    def assertWarnsRegex(self,  # type: ignore
+                         expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+                         expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+                         callable: Callable[..., Any],
+                         *args: Any, **kwargs: Any) -> None: ...
+    @overload
+    def assertWarnsRegex(self,
+                         expected_warning: Union[Type[Warning], Tuple[Type[Warning], ...]],
+                         expected_regex: Union[str, bytes, Pattern[str], Pattern[bytes]],
+                         msg: Any = ...) -> _AssertWarnsContext: ...
+    def assertLogs(
+        self, logger: Optional[logging.Logger] = ...,
+        level: Union[int, str, None] = ...
+    ) -> _AssertLogsContext: ...
+    def assertAlmostEqual(self, first: float, second: float, places: int = ...,
+                          msg: Any = ..., delta: float = ...) -> None: ...
+    @overload
+    def assertNotAlmostEqual(self, first: float, second: float, *,
+                             msg: Any = ...) -> None: ...
+    @overload
+    def assertNotAlmostEqual(self, first: float, second: float,
+                             places: int = ..., msg: Any = ...) -> None: ...
+    @overload
+    def assertNotAlmostEqual(self, first: float, second: float, *,
+                             msg: Any = ..., delta: float = ...) -> None: ...
+    def assertRegex(self, text: AnyStr, expected_regex: Union[AnyStr, Pattern[AnyStr]],
+                    msg: Any = ...) -> None: ...
+    def assertNotRegex(self, text: AnyStr, unexpected_regex: Union[AnyStr, Pattern[AnyStr]],
+                       msg: Any = ...) -> None: ...
+    def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any],
+                         msg: Any = ...) -> None: ...
+    def addTypeEqualityFunc(self, typeobj: Type[Any],
+                            function: Callable[..., None]) -> None: ...
+    def assertMultiLineEqual(self, first: str, second: str,
+                             msg: Any = ...) -> None: ...
+    def assertSequenceEqual(self, seq1: Sequence[Any], seq2: Sequence[Any],
+                            msg: Any = ...,
+                            seq_type: Type[Sequence[Any]] = ...) -> None: ...
+    def assertListEqual(self, list1: List[Any], list2: List[Any],
+                        msg: Any = ...) -> None: ...
+    def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...],
+                         msg: Any = ...) -> None: ...
+    def assertSetEqual(self, set1: Union[Set[Any], FrozenSet[Any]],
+                       set2: Union[Set[Any], FrozenSet[Any]], msg: Any = ...) -> None: ...
+    def assertDictEqual(self, d1: Dict[Any, Any], d2: Dict[Any, Any],
+                        msg: Any = ...) -> None: ...
+    def fail(self, msg: Any = ...) -> NoReturn: ...
+    def countTestCases(self) -> int: ...
+    def defaultTestResult(self) -> unittest.result.TestResult: ...
+    def id(self) -> str: ...
+    def shortDescription(self) -> Optional[str]: ...
+    def addCleanup(self, function: Callable[..., Any], *args: Any,
+                   **kwargs: Any) -> None: ...
+    def doCleanups(self) -> None: ...
+    def _formatMessage(self, msg: Optional[str], standardMsg: str) -> str: ...  # undocumented
+    def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ...  # undocumented
+    # below is deprecated
+    def failUnlessEqual(self, first: Any, second: Any,
+                        msg: Any = ...) -> None: ...
+    def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
+    def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
+    def assertNotEquals(self, first: Any, second: Any,
+                        msg: Any = ...) -> None: ...
+    def failUnless(self, expr: bool, msg: Any = ...) -> None: ...
+    def assert_(self, expr: bool, msg: Any = ...) -> None: ...
+    def failIf(self, expr: bool, msg: Any = ...) -> None: ...
+    @overload
+    def failUnlessRaises(self,  # type: ignore
+                         exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+                         callable: Callable[..., Any] = ...,
+                         *args: Any, **kwargs: Any) -> None: ...
+    @overload
+    def failUnlessRaises(self,
+                         exception: Union[Type[_E], Tuple[Type[_E], ...]],
+                         msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+    def failUnlessAlmostEqual(self, first: float, second: float,
+                              places: int = ..., msg: Any = ...) -> None: ...
+    def assertAlmostEquals(self, first: float, second: float, places: int = ...,
+                           msg: Any = ..., delta: float = ...) -> None: ...
+    def failIfAlmostEqual(self, first: float, second: float, places: int = ...,
+                          msg: Any = ...) -> None: ...
+    def assertNotAlmostEquals(self, first: float, second: float,
+                              places: int = ..., msg: Any = ...,
+                              delta: float = ...) -> None: ...
+    def assertRegexpMatches(self, text: AnyStr, regex: Union[AnyStr, Pattern[AnyStr]],
+                            msg: Any = ...) -> None: ...
+    @overload
+    def assertRaisesRegexp(self,  # type: ignore
+                           exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],
+                           callable: Callable[..., Any] = ...,
+                           *args: Any, **kwargs: Any) -> None: ...
+    @overload
+    def assertRaisesRegexp(self,
+                           exception: Union[Type[_E], Tuple[Type[_E], ...]],
+                           msg: Any = ...) -> _AssertRaisesContext[_E]: ...
+
+class FunctionTestCase(TestCase):
+    def __init__(self, testFunc: Callable[[], None],
+                 setUp: Optional[Callable[[], None]] = ...,
+                 tearDown: Optional[Callable[[], None]] = ...,
+                 description: Optional[str] = ...) -> None: ...
+
+class _AssertRaisesContext(Generic[_E]):
+    exception: _E
+    def __enter__(self) -> _AssertRaisesContext[_E]: ...
+    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
+                 exc_tb: Optional[TracebackType]) -> bool: ...
+
+class _AssertWarnsContext:
+    warning: Warning
+    filename: str
+    lineno: int
+    def __enter__(self) -> _AssertWarnsContext: ...
+    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
+                 exc_tb: Optional[TracebackType]) -> bool: ...
+
+class _AssertLogsContext:
+    records: List[logging.LogRecord]
+    output: List[str]
+    def __enter__(self) -> _AssertLogsContext: ...
+    def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],
+                 exc_tb: Optional[TracebackType]) -> bool: ...

stdlib/3/unittest/loader.pyi

@@ -0,0 +1,32 @@
+import sys
+import unittest.case
+import unittest.suite
+import unittest.result
+from types import ModuleType
+from typing import Any, Callable, List, Optional, Sequence, Type
+
+
+class TestLoader:
+    if sys.version_info >= (3, 5):
+        errors: List[Type[BaseException]]
+    testMethodPrefix: str
+    sortTestMethodsUsing: Callable[[str, str], bool]
+    suiteClass: Callable[[List[unittest.case.TestCase]], unittest.suite.TestSuite]
+    def loadTestsFromTestCase(self,
+                              testCaseClass: Type[unittest.case.TestCase]) -> unittest.suite.TestSuite: ...
+    if sys.version_info >= (3, 5):
+        def loadTestsFromModule(self, module: ModuleType,
+                                *, pattern: Any = ...) -> unittest.suite.TestSuite: ...
+    else:
+        def loadTestsFromModule(self,
+                                module: ModuleType) -> unittest.suite.TestSuite: ...
+    def loadTestsFromName(self, name: str,
+                          module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
+    def loadTestsFromNames(self, names: Sequence[str],
+                           module: Optional[ModuleType] = ...) -> unittest.suite.TestSuite: ...
+    def getTestCaseNames(self,
+                         testCaseClass: Type[unittest.case.TestCase]) -> Sequence[str]: ...
+    def discover(self, start_dir: str, pattern: str = ...,
+                 top_level_dir: Optional[str] = ...) -> unittest.suite.TestSuite: ...
+
+defaultTestLoader: TestLoader

stdlib/3/unittest/result.pyi

@@ -0,0 +1,36 @@
+from typing import Any, List, Optional, Tuple, Type
+from types import TracebackType
+import unittest.case
+
+
+_SysExcInfoType = Tuple[Optional[Type[BaseException]],
+                        Optional[BaseException],
+                        Optional[TracebackType]]
+
+
+class TestResult:
+    errors: List[Tuple[unittest.case.TestCase, str]]
+    failures: List[Tuple[unittest.case.TestCase, str]]
+    skipped: List[Tuple[unittest.case.TestCase, str]]
+    expectedFailures: List[Tuple[unittest.case.TestCase, str]]
+    unexpectedSuccesses: List[unittest.case.TestCase]
+    shouldStop: bool
+    testsRun: int
+    buffer: bool
+    failfast: bool
+    tb_locals: bool
+    def wasSuccessful(self) -> bool: ...
+    def stop(self) -> None: ...
+    def startTest(self, test: unittest.case.TestCase) -> None: ...
+    def stopTest(self, test: unittest.case.TestCase) -> None: ...
+    def startTestRun(self) -> None: ...
+    def stopTestRun(self) -> None: ...
+    def addError(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
+    def addFailure(self, test: unittest.case.TestCase, err: _SysExcInfoType) -> None: ...
+    def addSuccess(self, test: unittest.case.TestCase) -> None: ...
+    def addSkip(self, test: unittest.case.TestCase, reason: str) -> None: ...
+    def addExpectedFailure(self, test: unittest.case.TestCase,
+                           err: _SysExcInfoType) -> None: ...
+    def addUnexpectedSuccess(self, test: unittest.case.TestCase) -> None: ...
+    def addSubTest(self, test: unittest.case.TestCase, subtest: unittest.case.TestCase,
+                   outcome: Optional[_SysExcInfoType]) -> None: ...

stdlib/3/unittest/runner.pyi

@@ -0,0 +1,40 @@
+from typing import Callable, Optional, TextIO, Tuple, Type, Union
+import sys
+import unittest.case
+import unittest.result
+import unittest.suite
+
+
+_ResultClassType = Callable[[TextIO, bool, int], unittest.result.TestResult]
+
+
+class TextTestResult(unittest.result.TestResult):
+    separator1: str
+    separator2: str
+    def __init__(self, stream: TextIO, descriptions: bool,
+                 verbosity: int) -> None: ...
+    def getDescription(self, test: unittest.case.TestCase) -> str: ...
+    def printErrors(self) -> None: ...
+    def printErrorList(self, flavour: str, errors: Tuple[unittest.case.TestCase, str]) -> None: ...
+
+
+class TestRunner:
+    def run(self, test: Union[unittest.suite.TestSuite, unittest.case.TestCase]) -> unittest.result.TestResult: ...
+
+
+class TextTestRunner(TestRunner):
+    if sys.version_info >= (3, 5):
+        def __init__(self, stream: Optional[TextIO] = ...,
+                     descriptions: bool = ..., verbosity: int = ...,
+                     failfast: bool = ..., buffer: bool = ...,
+                     resultclass: Optional[_ResultClassType] = ...,
+                     warnings: Optional[Type[Warning]] = ...,
+                     *, tb_locals: bool = ...) -> None: ...
+    else:
+        def __init__(self,
+                     stream: Optional[TextIO] = ...,
+                     descriptions: bool = ..., verbosity: int = ...,
+                     failfast: bool = ..., buffer: bool = ...,
+                     resultclass: Optional[_ResultClassType] = ...,
+                     warnings: Optional[Type[Warning]] = ...) -> None: ...
+    def _makeResult(self) -> unittest.result.TestResult: ...

stdlib/3/unittest/signals.pyi

@@ -0,0 +1,14 @@
+from typing import Any, Callable, overload, TypeVar
+import unittest.result
+
+
+_F = TypeVar('_F', bound=Callable[..., Any])
+
+
+def installHandler() -> None: ...
+def registerResult(result: unittest.result.TestResult) -> None: ...
+def removeResult(result: unittest.result.TestResult) -> bool: ...
+@overload
+def removeHandler() -> None: ...
+@overload
+def removeHandler(function: _F) -> _F: ...

stdlib/3/unittest/suite.pyi

@@ -0,0 +1,22 @@
+from typing import Iterable, Iterator, List, Union
+import unittest.case
+import unittest.result
+
+
+_TestType = Union[unittest.case.TestCase, TestSuite]
+
+
+class BaseTestSuite(Iterable[_TestType]):
+    _tests: List[unittest.case.TestCase]
+    _removed_tests: int
+    def __init__(self, tests: Iterable[_TestType] = ...) -> None: ...
+    def __call__(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...
+    def addTest(self, test: _TestType) -> None: ...
+    def addTests(self, tests: Iterable[_TestType]) -> None: ...
+    def run(self, result: unittest.result.TestResult) -> unittest.result.TestResult: ...
+    def debug(self) -> None: ...
+    def countTestCases(self) -> int: ...
+    def __iter__(self) -> Iterator[_TestType]: ...
+
+
+class TestSuite(BaseTestSuite): ...