.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/stdlib/3/unittest/__init__.pyi

   1 # Stubs for unittest\r
   2 \r
   3 from typing import (\r
   4     Any, Callable, Container, ContextManager, Dict, FrozenSet, Generic, Iterable,\r
   5     Iterator, List, NoReturn, Optional, overload, Pattern, Sequence, Set, TextIO,\r
   6     Tuple, Type, TypeVar, Union\r
   7 )\r
   8 import logging\r
   9 import sys\r
  10 from types import ModuleType, TracebackType\r
  11 \r
  12 \r
  13 _T = TypeVar('_T')\r
  14 _FT = TypeVar('_FT', bound=Callable[..., Any])\r
  15 _E = TypeVar('_E', bound=Exception)\r
  16 \r
  17 \r
  18 def expectedFailure(func: _FT) -> _FT: ...\r
  19 def skip(reason: str) -> Callable[[_FT], _FT]: ...\r
  20 def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ...\r
  21 def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ...\r
  22 \r
  23 class SkipTest(Exception):\r
  24     def __init__(self, reason: str) -> None: ...\r
  25 \r
  26 \r
  27 class TestCase:\r
  28     failureException = ...  # type: Type[BaseException]\r
  29     longMessage = ...  # type: bool\r
  30     maxDiff = ...  # type: Optional[int]\r
  31     def __init__(self, methodName: str = ...) -> None: ...\r
  32     def setUp(self) -> None: ...\r
  33     def tearDown(self) -> None: ...\r
  34     @classmethod\r
  35     def setUpClass(cls) -> None: ...\r
  36     @classmethod\r
  37     def tearDownClass(cls) -> None: ...\r
  38     def run(self, result: Optional[TestResult] = ...) -> TestCase: ...\r
  39     def skipTest(self, reason: Any) -> None: ...\r
  40     def subTest(self, msg: Any = ..., **params: Any) -> ContextManager[None]: ...\r
  41     def debug(self) -> None: ...\r
  42     def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...\r
  43     def assertNotEqual(self, first: Any, second: Any,\r
  44                        msg: Any = ...) -> None: ...\r
  45     def assertTrue(self, expr: Any, msg: Any = ...) -> None: ...\r
  46     def assertFalse(self, expr: Any, msg: Any = ...) -> None: ...\r
  47     def assertIs(self, first: Any, second: Any, msg: Any = ...) -> None: ...\r
  48     def assertIsNot(self, first: Any, second: Any,\r
  49                     msg: Any = ...) -> None: ...\r
  50     def assertIsNone(self, expr: Any, msg: Any = ...) -> None: ...\r
  51     def assertIsNotNone(self, expr: Any, msg: Any = ...) -> None: ...\r
  52     def assertIn(self, member: Any, container: Container[Any],\r
  53                  msg: Any = ...) -> None: ...\r
  54     def assertNotIn(self, member: Any, container: Container[Any],\r
  55                     msg: Any = ...) -> None: ...\r
  56     def assertIsInstance(self, obj: Any,\r
  57                          cls: Union[type, Tuple[type, ...]],\r
  58                          msg: Any = ...) -> None: ...\r
  59     def assertNotIsInstance(self, obj: Any,\r
  60                             cls: Union[type, Tuple[type, ...]],\r
  61                             msg: Any = ...) -> None: ...\r
  62     def assertGreater(self, first: Any, second: Any,\r
  63                       msg: Any = ...) -> None: ...\r
  64     def assertGreaterEqual(self, first: Any, second: Any,\r
  65                            msg: Any = ...) -> None: ...\r
  66     def assertLess(self, first: Any, second: Any, msg: Any = ...) -> None: ...\r
  67     def assertLessEqual(self, first: Any, second: Any,\r
  68                         msg: Any = ...) -> None: ...\r
  69     @overload\r
  70     def assertRaises(self,  # type: ignore\r
  71                      exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],\r
  72                      callable: Callable[..., Any],\r
  73                      *args: Any, **kwargs: Any) -> None: ...\r
  74     @overload\r
  75     def assertRaises(self,\r
  76                      exception: Union[Type[_E], Tuple[Type[_E], ...]],\r
  77                      msg: Any = ...) -> _AssertRaisesContext[_E]: ...\r
  78     @overload\r
  79     def assertRaisesRegex(self,  # type: ignore\r
  80                           exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],\r
  81                           callable: Callable[..., Any],\r
  82                           *args: Any, **kwargs: Any) -> None: ...\r
  83     @overload\r
  84     def assertRaisesRegex(self,\r
  85                           exception: Union[Type[_E], Tuple[Type[_E], ...]],\r
  86                           msg: Any = ...) -> _AssertRaisesContext[_E]: ...\r
  87     @overload\r
  88     def assertWarns(self,  # type: ignore\r
  89                     exception: Union[Type[Warning], Tuple[Type[Warning], ...]],\r
  90                     callable: Callable[..., Any],\r
  91                     *args: Any, **kwargs: Any) -> None: ...\r
  92     @overload\r
  93     def assertWarns(self,\r
  94                     exception: Union[Type[Warning], Tuple[Type[Warning], ...]],\r
  95                     msg: Any = ...) -> _AssertWarnsContext: ...\r
  96     @overload\r
  97     def assertWarnsRegex(self,  # type: ignore\r
  98                          exception: Union[Type[Warning], Tuple[Type[Warning], ...]],\r
  99                          callable: Callable[..., Any],\r
 100                          *args: Any, **kwargs: Any) -> None: ...\r
 101     @overload\r
 102     def assertWarnsRegex(self,\r
 103                          exception: Union[Type[Warning], Tuple[Type[Warning], ...]],\r
 104                          msg: Any = ...) -> _AssertWarnsContext: ...\r
 105     def assertLogs(\r
 106         self, logger: Optional[logging.Logger] = ...,\r
 107         level: Union[int, str, None] = ...\r
 108     ) -> _AssertLogsContext: ...\r
 109     def assertAlmostEqual(self, first: float, second: float, places: int = ...,\r
 110                           msg: Any = ..., delta: float = ...) -> None: ...\r
 111     def assertNotAlmostEqual(self, first: float, second: float,\r
 112                              places: int = ..., msg: Any = ...,\r
 113                              delta: float = ...) -> None: ...\r
 114     def assertRegex(self, text: str, regex: Union[str, Pattern[str]],\r
 115                     msg: Any = ...) -> None: ...\r
 116     def assertNotRegex(self, text: str, regex: Union[str, Pattern[str]],\r
 117                        msg: Any = ...) -> None: ...\r
 118     def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any],\r
 119                          msg: Any = ...) -> None: ...\r
 120     def addTypeEqualityFunc(self, typeobj: Type[Any],\r
 121                             function: Callable[..., None]) -> None: ...\r
 122     def assertMultiLineEqual(self, first: str, second: str,\r
 123                              msg: Any = ...) -> None: ...\r
 124     def assertSequenceEqual(self, first: Sequence[Any], second: Sequence[Any],\r
 125                             msg: Any = ...,\r
 126                             seq_type: Type[Sequence[Any]] = ...) -> None: ...\r
 127     def assertListEqual(self, first: List[Any], second: List[Any],\r
 128                         msg: Any = ...) -> None: ...\r
 129     def assertTupleEqual(self, first: Tuple[Any, ...], second: Tuple[Any, ...],\r
 130                          msg: Any = ...) -> None: ...\r
 131     def assertSetEqual(self, first: Union[Set[Any], FrozenSet[Any]],\r
 132                        second: Union[Set[Any], FrozenSet[Any]], msg: Any = ...) -> None: ...\r
 133     def assertDictEqual(self, first: Dict[Any, Any], second: Dict[Any, Any],\r
 134                         msg: Any = ...) -> None: ...\r
 135     def fail(self, msg: Any = ...) -> NoReturn: ...\r
 136     def countTestCases(self) -> int: ...\r
 137     def defaultTestResult(self) -> TestResult: ...\r
 138     def id(self) -> str: ...\r
 139     def shortDescription(self) -> Optional[str]: ...\r
 140     def addCleanup(self, function: Callable[..., Any], *args: Any,\r
 141                    **kwargs: Any) -> None: ...\r
 142     def doCleanups(self) -> None: ...\r
 143     # below is deprecated\r
 144     def failUnlessEqual(self, first: Any, second: Any,\r
 145                         msg: Any = ...) -> None: ...\r
 146     def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...\r
 147     def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...\r
 148     def assertNotEquals(self, first: Any, second: Any,\r
 149                         msg: Any = ...) -> None: ...\r
 150     def failUnless(self, expr: bool, msg: Any = ...) -> None: ...\r
 151     def assert_(self, expr: bool, msg: Any = ...) -> None: ...\r
 152     def failIf(self, expr: bool, msg: Any = ...) -> None: ...\r
 153     @overload\r
 154     def failUnlessRaises(self,  # type: ignore\r
 155                          exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],\r
 156                          callable: Callable[..., Any] = ...,\r
 157                          *args: Any, **kwargs: Any) -> None: ...\r
 158     @overload\r
 159     def failUnlessRaises(self,\r
 160                          exception: Union[Type[_E], Tuple[Type[_E], ...]],\r
 161                          msg: Any = ...) -> _AssertRaisesContext[_E]: ...\r
 162     def failUnlessAlmostEqual(self, first: float, second: float,\r
 163                               places: int = ..., msg: Any = ...) -> None: ...\r
 164     def assertAlmostEquals(self, first: float, second: float, places: int = ...,\r
 165                            msg: Any = ..., delta: float = ...) -> None: ...\r
 166     def failIfAlmostEqual(self, first: float, second: float, places: int = ...,\r
 167                           msg: Any = ...) -> None: ...\r
 168     def assertNotAlmostEquals(self, first: float, second: float,\r
 169                               places: int = ..., msg: Any = ...,\r
 170                               delta: float = ...) -> None: ...\r
 171     def assertRegexpMatches(self, text: str, regex: Union[str, Pattern[str]],\r
 172                             msg: Any = ...) -> None: ...\r
 173     @overload\r
 174     def assertRaisesRegexp(self,  # type: ignore\r
 175                            exception: Union[Type[BaseException], Tuple[Type[BaseException], ...]],\r
 176                            callable: Callable[..., Any] = ...,\r
 177                            *args: Any, **kwargs: Any) -> None: ...\r
 178     @overload\r
 179     def assertRaisesRegexp(self,\r
 180                            exception: Union[Type[_E], Tuple[Type[_E], ...]],\r
 181                            msg: Any = ...) -> _AssertRaisesContext[_E]: ...\r
 182 \r
 183 class FunctionTestCase(TestCase):\r
 184     def __init__(self, testFunc: Callable[[], None],\r
 185                  setUp: Optional[Callable[[], None]] = ...,\r
 186                  tearDown: Optional[Callable[[], None]] = ...,\r
 187                  description: Optional[str] = ...) -> None: ...\r
 188 \r
 189 class _AssertRaisesContext(Generic[_E]):\r
 190     exception = ...  # type: _E\r
 191     def __enter__(self) -> _AssertRaisesContext[_E]: ...\r
 192     def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],\r
 193                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 194 \r
 195 class _AssertWarnsContext:\r
 196     warning = ...  # type: Warning\r
 197     filename = ...  # type: str\r
 198     lineno = ...  # type: int\r
 199     def __enter__(self) -> _AssertWarnsContext: ...\r
 200     def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],\r
 201                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 202 \r
 203 class _AssertLogsContext:\r
 204     records = ...  # type: List[logging.LogRecord]\r
 205     output = ...  # type: List[str]\r
 206     def __enter__(self) -> _AssertLogsContext: ...\r
 207     def __exit__(self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException],\r
 208                  exc_tb: Optional[TracebackType]) -> bool: ...\r
 209 \r
 210 \r
 211 _TestType = Union[TestCase, TestSuite]\r
 212 \r
 213 class TestSuite(Iterable[_TestType]):\r
 214     def __init__(self, tests: Iterable[_TestType] = ...) -> None: ...\r
 215     def addTest(self, test: _TestType) -> None: ...\r
 216     def addTests(self, tests: Iterable[_TestType]) -> None: ...\r
 217     def run(self, result: TestResult) -> TestResult: ...\r
 218     def debug(self) -> None: ...\r
 219     def countTestCases(self) -> int: ...\r
 220     def __iter__(self) -> Iterator[_TestType]: ...\r
 221 \r
 222 \r
 223 class TestLoader:\r
 224     if sys.version_info >= (3, 5):\r
 225         errors = ...  # type: List[Type[BaseException]]\r
 226     testMethodPrefix = ...  # type: str\r
 227     sortTestMethodsUsing = ...  # type: Callable[[str, str], bool]\r
 228     suiteClass = ...  # type: Callable[[List[TestCase]], TestSuite]\r
 229     def loadTestsFromTestCase(self,\r
 230                               testCaseClass: Type[TestCase]) -> TestSuite: ...\r
 231     if sys.version_info >= (3, 5):\r
 232         def loadTestsFromModule(self, module: ModuleType,\r
 233                                 *, pattern: Any = ...) -> TestSuite: ...\r
 234     else:\r
 235         def loadTestsFromModule(self,\r
 236                                 module: ModuleType) -> TestSuite: ...\r
 237     def loadTestsFromName(self, name: str,\r
 238                           module: Optional[ModuleType] = ...) -> TestSuite: ...\r
 239     def loadTestsFromNames(self, names: Sequence[str],\r
 240                            module: Optional[ModuleType] = ...) -> TestSuite: ...\r
 241     def getTestCaseNames(self,\r
 242                          testCaseClass: Type[TestCase]) -> Sequence[str]: ...\r
 243     def discover(self, start_dir: str, pattern: str = ...,\r
 244                  top_level_dir: Optional[str] = ...) -> TestSuite: ...\r
 245 \r
 246 _SysExcInfoType = Tuple[Optional[Type[BaseException]],\r
 247                         Optional[BaseException],\r
 248                         Optional[TracebackType]]\r
 249 \r
 250 class TestResult:\r
 251     errors = ...  # type: List[Tuple[TestCase, str]]\r
 252     failures = ...  # type: List[Tuple[TestCase, str]]\r
 253     skipped = ...  # type: List[Tuple[TestCase, str]]\r
 254     expectedFailures = ...  # type: List[Tuple[TestCase, str]]\r
 255     unexpectedSuccesses = ...  # type: List[TestCase]\r
 256     shouldStop = ...  # type: bool\r
 257     testsRun = ...  # type: int\r
 258     buffer = ...  # type: bool\r
 259     failfast = ...  # type: bool\r
 260     tb_locals = ...  # type: bool\r
 261     def wasSuccessful(self) -> bool: ...\r
 262     def stop(self) -> None: ...\r
 263     def startTest(self, test: TestCase) -> None: ...\r
 264     def stopTest(self, test: TestCase) -> None: ...\r
 265     def startTestRun(self) -> None: ...\r
 266     def stopTestRun(self) -> None: ...\r
 267     def addError(self, test: TestCase, err: _SysExcInfoType) -> None: ...\r
 268     def addFailure(self, test: TestCase, err: _SysExcInfoType) -> None: ...\r
 269     def addSuccess(self, test: TestCase) -> None: ...\r
 270     def addSkip(self, test: TestCase, reason: str) -> None: ...\r
 271     def addExpectedFailure(self, test: TestCase,\r
 272                            err: _SysExcInfoType) -> None: ...\r
 273     def addUnexpectedSuccess(self, test: TestCase) -> None: ...\r
 274     def addSubTest(self, test: TestCase, subtest: TestCase,\r
 275                    outcome: Optional[_SysExcInfoType]) -> None: ...\r
 276 \r
 277 class TextTestResult(TestResult):\r
 278     def __init__(self, stream: TextIO, descriptions: bool,\r
 279                  verbosity: int) -> None: ...\r
 280 _TextTestResult = TextTestResult\r
 281 \r
 282 defaultTestLoader = ...  # type: TestLoader\r
 283 \r
 284 _ResultClassType = Callable[[TextIO, bool, int], TestResult]\r
 285 \r
 286 class TestRunner:\r
 287     def run(self, test: Union[TestSuite, TestCase]) -> TestResult: ...\r
 288 \r
 289 class TextTestRunner(TestRunner):\r
 290     if sys.version_info >= (3, 5):\r
 291         def __init__(self, stream: Optional[TextIO] = ...,\r
 292                      descriptions: bool = ..., verbosity: int = ...,\r
 293                      failfast: bool = ..., buffer: bool = ...,\r
 294                      resultclass: Optional[_ResultClassType] = ...,\r
 295                      warnings: Optional[Type[Warning]] = ...,\r
 296                      *, tb_locals: bool = ...) -> None: ...\r
 297     else:\r
 298         def __init__(self,\r
 299                      stream: Optional[TextIO] = ...,\r
 300                      descriptions: bool = ..., verbosity: int = ...,\r
 301                      failfast: bool = ..., buffer: bool = ...,\r
 302                      resultclass: Optional[_ResultClassType] = ...,\r
 303                      warnings: Optional[Type[Warning]] = ...) -> None: ...\r
 304     def _makeResult(self) -> TestResult: ...\r
 305 \r
 306 # not really documented\r
 307 class TestProgram:\r
 308     result = ...  # type: TestResult\r
 309 \r
 310 def main(module: str = ...,\r
 311          defaultTest: Union[str, Iterable[str], None] = ...,\r
 312          argv: Optional[List[str]] = ...,\r
 313          testRunner: Union[Type[TestRunner], TestRunner, None] = ...,\r
 314          testLoader: TestLoader = ..., exit: bool = ..., verbosity: int = ...,\r
 315          failfast: Optional[bool] = ..., catchbreak: Optional[bool] = ...,\r
 316          buffer: Optional[bool] = ...,\r
 317          warnings: Optional[str] = ...) -> TestProgram: ...\r
 318 \r
 319 def load_tests(loader: TestLoader, tests: TestSuite,\r
 320                pattern: Optional[str]) -> TestSuite: ...\r
 321 \r
 322 def installHandler() -> None: ...\r
 323 def registerResult(result: TestResult) -> None: ...\r
 324 def removeResult(result: TestResult) -> bool: ...\r
 325 @overload\r
 326 def removeHandler() -> None: ...\r
 327 @overload\r
 328 def removeHandler(function: _FT) -> _FT: ...\r