.config/coc/extensions/node_modules/coc-pyright/node_modules/pyright/dist/typeshed-fallback/stdlib/unittest/case.pyi

   1 import datetime
   2 import logging
   3 import sys
   4 import unittest.result
   5 from _typeshed import Self
   6 from collections.abc import Set  # equivalent to typing.AbstractSet, not builtins.set
   7 from contextlib import AbstractContextManager
   8 from types import TracebackType
   9 from typing import (
  10     Any,
  11     AnyStr,
  12     Callable,
  13     Container,
  14     Generic,
  15     Iterable,
  16     Mapping,
  17     NamedTuple,
  18     NoReturn,
  19     Pattern,
  20     Sequence,
  21     Tuple,
  22     Type,
  23     TypeVar,
  24     overload,
  25 )
  26 from warnings import WarningMessage
  27
  28 if sys.version_info >= (3, 9):
  29     from types import GenericAlias
  30
  31 _E = TypeVar("_E", bound=BaseException)
  32 _FT = TypeVar("_FT", bound=Callable[..., Any])
  33
  34 if sys.version_info >= (3, 8):
  35     def addModuleCleanup(__function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
  36     def doModuleCleanups() -> None: ...
  37
  38 def expectedFailure(test_item: _FT) -> _FT: ...
  39 def skip(reason: str) -> Callable[[_FT], _FT]: ...
  40 def skipIf(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
  41 def skipUnless(condition: object, reason: str) -> Callable[[_FT], _FT]: ...
  42
  43 class SkipTest(Exception):
  44     def __init__(self, reason: str) -> None: ...
  45
  46 class TestCase:
  47     failureException: Type[BaseException]
  48     longMessage: bool
  49     maxDiff: int | None
  50     # undocumented
  51     _testMethodName: str
  52     # undocumented
  53     _testMethodDoc: str
  54     def __init__(self, methodName: str = ...) -> None: ...
  55     def setUp(self) -> None: ...
  56     def tearDown(self) -> None: ...
  57     @classmethod
  58     def setUpClass(cls) -> None: ...
  59     @classmethod
  60     def tearDownClass(cls) -> None: ...
  61     def run(self, result: unittest.result.TestResult | None = ...) -> unittest.result.TestResult | None: ...
  62     def __call__(self, result: unittest.result.TestResult | None = ...) -> unittest.result.TestResult | None: ...
  63     def skipTest(self, reason: Any) -> None: ...
  64     def subTest(self, msg: Any = ..., **params: Any) -> AbstractContextManager[None]: ...
  65     def debug(self) -> None: ...
  66     def _addSkip(self, result: unittest.result.TestResult, test_case: TestCase, reason: str) -> None: ...
  67     def assertEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
  68     def assertNotEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
  69     def assertTrue(self, expr: Any, msg: Any = ...) -> None: ...
  70     def assertFalse(self, expr: Any, msg: Any = ...) -> None: ...
  71     def assertIs(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
  72     def assertIsNot(self, expr1: Any, expr2: Any, msg: Any = ...) -> None: ...
  73     def assertIsNone(self, obj: Any, msg: Any = ...) -> None: ...
  74     def assertIsNotNone(self, obj: Any, msg: Any = ...) -> None: ...
  75     def assertIn(self, member: Any, container: Iterable[Any] | Container[Any], msg: Any = ...) -> None: ...
  76     def assertNotIn(self, member: Any, container: Iterable[Any] | Container[Any], msg: Any = ...) -> None: ...
  77     def assertIsInstance(self, obj: Any, cls: type | Tuple[type, ...], msg: Any = ...) -> None: ...
  78     def assertNotIsInstance(self, obj: Any, cls: type | Tuple[type, ...], msg: Any = ...) -> None: ...
  79     def assertGreater(self, a: Any, b: Any, msg: Any = ...) -> None: ...
  80     def assertGreaterEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
  81     def assertLess(self, a: Any, b: Any, msg: Any = ...) -> None: ...
  82     def assertLessEqual(self, a: Any, b: Any, msg: Any = ...) -> None: ...
  83     @overload
  84     def assertRaises(  # type: ignore
  85         self,
  86         expected_exception: Type[BaseException] | Tuple[Type[BaseException], ...],
  87         callable: Callable[..., Any],
  88         *args: Any,
  89         **kwargs: Any,
  90     ) -> None: ...
  91     @overload
  92     def assertRaises(self, expected_exception: Type[_E] | Tuple[Type[_E], ...], msg: Any = ...) -> _AssertRaisesContext[_E]: ...
  93     @overload
  94     def assertRaisesRegex(  # type: ignore
  95         self,
  96         expected_exception: Type[BaseException] | Tuple[Type[BaseException], ...],
  97         expected_regex: str | bytes | Pattern[str] | Pattern[bytes],
  98         callable: Callable[..., Any],
  99         *args: Any,
 100         **kwargs: Any,
 101     ) -> None: ...
 102     @overload
 103     def assertRaisesRegex(
 104         self,
 105         expected_exception: Type[_E] | Tuple[Type[_E], ...],
 106         expected_regex: str | bytes | Pattern[str] | Pattern[bytes],
 107         msg: Any = ...,
 108     ) -> _AssertRaisesContext[_E]: ...
 109     @overload
 110     def assertWarns(  # type: ignore
 111         self, expected_warning: Type[Warning] | Tuple[Type[Warning], ...], callable: Callable[..., Any], *args: Any, **kwargs: Any
 112     ) -> None: ...
 113     @overload
 114     def assertWarns(self, expected_warning: Type[Warning] | Tuple[Type[Warning], ...], msg: Any = ...) -> _AssertWarnsContext: ...
 115     @overload
 116     def assertWarnsRegex(  # type: ignore
 117         self,
 118         expected_warning: Type[Warning] | Tuple[Type[Warning], ...],
 119         expected_regex: str | bytes | Pattern[str] | Pattern[bytes],
 120         callable: Callable[..., Any],
 121         *args: Any,
 122         **kwargs: Any,
 123     ) -> None: ...
 124     @overload
 125     def assertWarnsRegex(
 126         self,
 127         expected_warning: Type[Warning] | Tuple[Type[Warning], ...],
 128         expected_regex: str | bytes | Pattern[str] | Pattern[bytes],
 129         msg: Any = ...,
 130     ) -> _AssertWarnsContext: ...
 131     def assertLogs(self, logger: str | logging.Logger | None = ..., level: int | str | None = ...) -> _AssertLogsContext: ...
 132     @overload
 133     def assertAlmostEqual(
 134         self, first: float, second: float, places: int | None = ..., msg: Any = ..., delta: float | None = ...
 135     ) -> None: ...
 136     @overload
 137     def assertAlmostEqual(
 138         self,
 139         first: datetime.datetime,
 140         second: datetime.datetime,
 141         places: int | None = ...,
 142         msg: Any = ...,
 143         delta: datetime.timedelta | None = ...,
 144     ) -> None: ...
 145     @overload
 146     def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ...) -> None: ...
 147     @overload
 148     def assertNotAlmostEqual(self, first: float, second: float, places: int | None = ..., msg: Any = ...) -> None: ...
 149     @overload
 150     def assertNotAlmostEqual(self, first: float, second: float, *, msg: Any = ..., delta: float | None = ...) -> None: ...
 151     @overload
 152     def assertNotAlmostEqual(
 153         self,
 154         first: datetime.datetime,
 155         second: datetime.datetime,
 156         places: int | None = ...,
 157         msg: Any = ...,
 158         delta: datetime.timedelta | None = ...,
 159     ) -> None: ...
 160     def assertRegex(self, text: AnyStr, expected_regex: AnyStr | Pattern[AnyStr], msg: Any = ...) -> None: ...
 161     def assertNotRegex(self, text: AnyStr, unexpected_regex: AnyStr | Pattern[AnyStr], msg: Any = ...) -> None: ...
 162     def assertCountEqual(self, first: Iterable[Any], second: Iterable[Any], msg: Any = ...) -> None: ...
 163     def addTypeEqualityFunc(self, typeobj: Type[Any], function: Callable[..., None]) -> None: ...
 164     def assertMultiLineEqual(self, first: str, second: str, msg: Any = ...) -> None: ...
 165     def assertSequenceEqual(
 166         self, seq1: Sequence[Any], seq2: Sequence[Any], msg: Any = ..., seq_type: Type[Sequence[Any]] | None = ...
 167     ) -> None: ...
 168     def assertListEqual(self, list1: list[Any], list2: list[Any], msg: Any = ...) -> None: ...
 169     def assertTupleEqual(self, tuple1: Tuple[Any, ...], tuple2: Tuple[Any, ...], msg: Any = ...) -> None: ...
 170     def assertSetEqual(self, set1: Set[object], set2: Set[object], msg: Any = ...) -> None: ...
 171     def assertDictEqual(self, d1: Mapping[Any, object], d2: Mapping[Any, object], msg: Any = ...) -> None: ...
 172     def fail(self, msg: Any = ...) -> NoReturn: ...
 173     def countTestCases(self) -> int: ...
 174     def defaultTestResult(self) -> unittest.result.TestResult: ...
 175     def id(self) -> str: ...
 176     def shortDescription(self) -> str | None: ...
 177     if sys.version_info >= (3, 8):
 178         def addCleanup(self, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
 179     else:
 180         def addCleanup(self, function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
 181     def doCleanups(self) -> None: ...
 182     if sys.version_info >= (3, 8):
 183         @classmethod
 184         def addClassCleanup(cls, __function: Callable[..., Any], *args: Any, **kwargs: Any) -> None: ...
 185         @classmethod
 186         def doClassCleanups(cls) -> None: ...
 187     def _formatMessage(self, msg: str | None, standardMsg: str) -> str: ...  # undocumented
 188     def _getAssertEqualityFunc(self, first: Any, second: Any) -> Callable[..., None]: ...  # undocumented
 189     if sys.version_info < (3, 11):
 190         def failUnlessEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
 191         def assertEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
 192         def failIfEqual(self, first: Any, second: Any, msg: Any = ...) -> None: ...
 193         def assertNotEquals(self, first: Any, second: Any, msg: Any = ...) -> None: ...
 194         def failUnless(self, expr: bool, msg: Any = ...) -> None: ...
 195         def assert_(self, expr: bool, msg: Any = ...) -> None: ...
 196         def failIf(self, expr: bool, msg: Any = ...) -> None: ...
 197         @overload
 198         def failUnlessRaises(  # type: ignore
 199             self,
 200             exception: Type[BaseException] | Tuple[Type[BaseException], ...],
 201             callable: Callable[..., Any] = ...,
 202             *args: Any,
 203             **kwargs: Any,
 204         ) -> None: ...
 205         @overload
 206         def failUnlessRaises(self, exception: Type[_E] | Tuple[Type[_E], ...], msg: Any = ...) -> _AssertRaisesContext[_E]: ...
 207         def failUnlessAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ...
 208         def assertAlmostEquals(
 209             self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...
 210         ) -> None: ...
 211         def failIfAlmostEqual(self, first: float, second: float, places: int = ..., msg: Any = ...) -> None: ...
 212         def assertNotAlmostEquals(
 213             self, first: float, second: float, places: int = ..., msg: Any = ..., delta: float = ...
 214         ) -> None: ...
 215         def assertRegexpMatches(self, text: AnyStr, regex: AnyStr | Pattern[AnyStr], msg: Any = ...) -> None: ...
 216         def assertNotRegexpMatches(self, text: AnyStr, regex: AnyStr | Pattern[AnyStr], msg: Any = ...) -> None: ...
 217         @overload
 218         def assertRaisesRegexp(  # type: ignore
 219             self,
 220             exception: Type[BaseException] | Tuple[Type[BaseException], ...],
 221             expected_regex: str | bytes | Pattern[str] | Pattern[bytes],
 222             callable: Callable[..., Any],
 223             *args: Any,
 224             **kwargs: Any,
 225         ) -> None: ...
 226         @overload
 227         def assertRaisesRegexp(
 228             self,
 229             exception: Type[_E] | Tuple[Type[_E], ...],
 230             expected_regex: str | bytes | Pattern[str] | Pattern[bytes],
 231             msg: Any = ...,
 232         ) -> _AssertRaisesContext[_E]: ...
 233         def assertDictContainsSubset(
 234             self, subset: Mapping[Any, Any], dictionary: Mapping[Any, Any], msg: object = ...
 235         ) -> None: ...
 236
 237 class FunctionTestCase(TestCase):
 238     def __init__(
 239         self,
 240         testFunc: Callable[[], None],
 241         setUp: Callable[[], None] | None = ...,
 242         tearDown: Callable[[], None] | None = ...,
 243         description: str | None = ...,
 244     ) -> None: ...
 245     def runTest(self) -> None: ...
 246
 247 class _LoggingWatcher(NamedTuple):
 248     records: list[logging.LogRecord]
 249     output: list[str]
 250
 251 class _AssertRaisesContext(Generic[_E]):
 252     exception: _E
 253     def __enter__(self: Self) -> Self: ...
 254     def __exit__(
 255         self, exc_type: Type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
 256     ) -> bool: ...
 257     if sys.version_info >= (3, 9):
 258         def __class_getitem__(cls, item: Any) -> GenericAlias: ...
 259
 260 class _AssertWarnsContext:
 261     warning: WarningMessage
 262     filename: str
 263     lineno: int
 264     warnings: list[WarningMessage]
 265     def __enter__(self: Self) -> Self: ...
 266     def __exit__(
 267         self, exc_type: Type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
 268     ) -> None: ...
 269
 270 class _AssertLogsContext:
 271     LOGGING_FORMAT: str
 272     records: list[logging.LogRecord]
 273     output: list[str]
 274     def __init__(self, test_case: TestCase, logger_name: str, level: int) -> None: ...
 275     if sys.version_info >= (3, 10):
 276         def __enter__(self) -> _LoggingWatcher | None: ...
 277     else:
 278         def __enter__(self) -> _LoggingWatcher: ...
 279     def __exit__(
 280         self, exc_type: Type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
 281     ) -> bool | None: ...