assert_that.py

import warnings
from typing import Optional, TypeVar, cast, overload

from hamcrest.core.matcher import Matcher
from hamcrest.core.string_description import StringDescription

__author__ = "Jon Reid"
__copyright__ = "Copyright 2011 hamcrest.org"
__license__ = "BSD, see License.txt"
# unittest integration; hide these frames from tracebacks
__unittest = True
# py.test integration; hide these frames from tracebacks
__tracebackhide__ = True

T = TypeVar("T")

@overload
def assert_that(actual_or_assertion: T, matcher: Matcher[T], reason: str = "") -> None:
    ...

@overload
def assert_that(actual_or_assertion: bool, reason: str = "") -> None:
    ...

def assert_that(actual_or_assertion, matcher=None, reason=""):
    """Asserts that actual value satisfies matcher. (Can also assert plain
    boolean condition.)

:param actual: The object to evaluate as the actual value.
    :param matcher: The matcher to satisfy as the expected condition.
    :param reason: Optional explanation to include in failure description.

``assert_that`` passes the actual value to the matcher for evaluation. If
    the matcher is not satisfied, an exception is thrown describing the
    mismatch.

``assert_that`` is designed to integrate well with PyUnit and other unit
    testing frameworks. The exception raised for an unmet assertion is an
    :py:exc:`AssertionError`, which PyUnit reports as a test failure.

With a different set of parameters, ``assert_that`` can also verify a
    boolean condition:

.. function:: assert_that(assertion[, reason])

:param assertion:  Boolean condition to verify.
    :param reason:  Optional explanation to include in failure description.

This is equivalent to the :py:meth:`~unittest.TestCase.assertTrue` method
    of :py:class:`unittest.TestCase`, but offers greater flexibility in test
    writing by being a standalone function.

"""
    if isinstance(matcher, Matcher):
        _assert_match(actual=actual_or_assertion, matcher=matcher, reason=reason)
    else:
        if isinstance(actual_or_assertion, Matcher):
            warnings.warn("arg1 should be boolean, but was {}".format(type(actual_or_assertion)))
        _assert_bool(assertion=cast(bool, actual_or_assertion), reason=cast(str, matcher))

def _assert_match(actual: T, matcher: Matcher[T], reason: str) -> None:
    if not matcher.matches(actual):
        description = StringDescription()
        description.append_text(reason).append_text("\nExpected: ").append_description_of(
            matcher
        ).append_text("\n     but: ")
        matcher.describe_mismatch(actual, description)
        description.append_text("\n")
        raise AssertionError(description)

def _assert_bool(assertion: bool, reason: Optional[str] = None) -> None:
    if not assertion:
        if not reason:
            reason = "Assertion failed"
        raise AssertionError(reason)

docroot: /var/www/469ed2f6-4d4b-4a8a-9f5e-ee4ef04d3bc8/public_html

curdir: /usr/lib/python3/dist-packages/hamcrest/core

	.	4096
	..	4096
X	__init__.py	439
	__pycache__	4096
X	assert_that.py	2909
X	base_description.py	2028
X	base_matcher.py	1739
	core	4096
X	description.py	1535
	helpers	4096
X	matcher.py	2664
X	selfdescribing.py	638
X	selfdescribingvalue.py	928
X	string_description.py	940