Viewing file:  check_functions.py (7.38 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
from __future__ import annotations
import functools
import sys
from typing import (
Any,
Callable,
Container,
Protocol,
SupportsFloat,
SupportsIndex,
TypeVar,
Union,
)
if sys.version_info < (3, 10): # pragma: no cover
from typing_extensions import ParamSpec
else:
from typing import ParamSpec
import pytest
import math
from .check_log import log_failure
__all__ = [
"assert_equal",
"equal",
"not_equal",
"is_",
"is_not",
"is_true",
"is_false",
"is_none",
"is_not_none",
"is_nan",
"is_not_nan",
"is_in",
"is_not_in",
"is_instance",
"is_not_instance",
"almost_equal",
"not_almost_equal",
"greater",
"greater_equal",
"less",
"less_equal",
"between",
"between_equal",
"check_func",
"fail",
]
_P = ParamSpec("_P")
_T = TypeVar("_T")
class _ComparableGreaterThan(Protocol):
def __gt__(self, other: Any) -> bool: ... # pragma: no cover
class _ComparableGreaterThanOrEqual(Protocol):
def __ge__(self, other: Any) -> bool: ... # pragma: no cover
class _ComparableLessThan(Protocol):
def __lt__(self, other: Any) -> bool: ... # pragma: no cover
class _ComparableLessThanOrEqual(Protocol):
def __le__(self, other: Any) -> bool: ... # pragma: no cover
def check_func(func: Callable[_P, _T]) -> Callable[_P, bool]:
@functools.wraps(func)
def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> bool:
__tracebackhide__ = True
try:
func(*args, **kwargs)
return True
except AssertionError as e:
log_failure(e)
return False
return wrapper
def assert_equal(a: object, b: object, msg: str = "") -> None: # pragma: no cover
assert a == b, msg
def equal(a: object, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a == b:
return True
else:
log_failure(f"check {a} == {b}", msg)
return False
def not_equal(a: object, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a != b:
return True
else:
log_failure(f"check {a} != {b}", msg)
return False
def is_(a: object, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a is b:
return True
else:
log_failure(f"check {a} is {b}", msg)
return False
def is_not(a: object, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a is not b:
return True
else:
log_failure(f"check {a} is not {b}", msg)
return False
def is_true(x: object, msg: str = "") -> bool:
__tracebackhide__ = True
if bool(x):
return True
else:
log_failure(f"check bool({x})", msg)
return False
def is_false(x: object, msg: str = "") -> bool:
__tracebackhide__ = True
if not bool(x):
return True
else:
log_failure(f"check not bool({x})", msg)
return False
def is_none(x: object, msg: str = "") -> bool:
__tracebackhide__ = True
if x is None:
return True
else:
log_failure(f"check {x} is None", msg)
return False
def is_not_none(x: object, msg: str = "") -> bool:
__tracebackhide__ = True
if x is not None:
return True
else:
log_failure(f"check {x} is not None", msg)
return False
def is_nan(a: SupportsFloat | SupportsIndex, msg: str = "") -> bool:
__tracebackhide__ = True
if math.isnan(a):
return True
else:
log_failure(f"check {a} is NaN", msg)
return False
def is_not_nan(a: SupportsFloat | SupportsIndex, msg: str = "") -> bool:
__tracebackhide__ = True
if not math.isnan(a):
return True
else:
log_failure(f"check {a} is not NaN", msg)
return False
def is_in(a: _T, b: Container[_T], msg: str = "") -> bool:
__tracebackhide__ = True
if a in b:
return True
else:
log_failure(f"check {a} in {b}", msg)
return False
def is_not_in(a: _T, b: Container[_T], msg: str = "") -> bool:
__tracebackhide__ = True
if a not in b:
return True
else:
log_failure(f"check {a} not in {b}", msg)
return False
_TypeTuple = Union[type, tuple['_TypeTuple', ...]]
def is_instance(a: object, b: _TypeTuple, msg: str = "") -> bool:
__tracebackhide__ = True
if isinstance(a, b):
return True
else:
log_failure(f"check isinstance({a}, {b})", msg)
return False
def is_not_instance(a: object, b: _TypeTuple, msg: str = "") -> bool:
__tracebackhide__ = True
if not isinstance(a, b):
return True
else:
log_failure(f"check not isinstance({a}, {b})", msg)
return False
def almost_equal(
a: object, b: object, rel: Any = None, abs: Any = None, msg: str = ""
) -> bool:
"""
For rel and abs tolerance, see:
See https://docs.pytest.org/en/latest/builtin.html#pytest.approx
"""
__tracebackhide__ = True
if a == pytest.approx(b, rel, abs):
return True
else:
log_failure(f"check {a} == pytest.approx({b}, rel={rel}, abs={abs})", msg)
return False
def not_almost_equal(
a: object, b: object, rel: Any = None, abs: Any = None, msg: str = ""
) -> bool:
"""
For rel and abs tolerance, see:
See https://docs.pytest.org/en/latest/builtin.html#pytest.approx
"""
__tracebackhide__ = True
if a != pytest.approx(b, rel, abs):
return True
else:
log_failure(f"check {a} != pytest.approx({b}, rel={rel}, abs={abs})", msg)
return False
def greater(a: _ComparableGreaterThan, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a > b:
return True
else:
log_failure(f"check {a} > {b}", msg)
return False
def greater_equal(a: _ComparableGreaterThanOrEqual, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a >= b:
return True
else:
log_failure(f"check {a} >= {b}", msg)
return False
def less(a: _ComparableLessThan, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a < b:
return True
else:
log_failure(f"check {a} < {b}", msg)
return False
def less_equal(a: _ComparableLessThanOrEqual, b: object, msg: str = "") -> bool:
__tracebackhide__ = True
if a <= b:
return True
else:
log_failure(f"check {a} <= {b}", msg)
return False
def between(
b: Any, a: Any, c: Any, msg: str = "", ge: bool = False, le: bool = False
) -> bool:
__tracebackhide__ = True
if ge and le:
if a <= b <= c:
return True
else:
log_failure(f"check {a} <= {b} <= {c}", msg)
return False
elif ge:
if a <= b < c:
return True
else:
log_failure(f"check {a} <= {b} < {c}", msg)
return False
elif le:
if a < b <= c:
return True
else:
log_failure(f"check {a} < {b} <= {c}", msg)
return False
else:
if a < b < c:
return True
else:
log_failure(f"check {a} < {b} < {c}", msg)
return False
def between_equal(
b: _ComparableLessThanOrEqual,
a: _ComparableLessThanOrEqual,
c: object,
msg:str = "",
) -> bool:
__tracebackhide__ = True
return between(b, a, c, msg, ge=True, le=True)
def fail(msg: str) -> None:
__tracebackhide__ = True
log_failure(msg)
|