text: # pylint: disable=missing-docstring
  # pylint: disable=invalid-name
  # pylint: disable=unused-argument
  # pylint: disable=no-self-use
  # pylint: disable=unused-variable
  
  import unittest
  from typing import Optional
  
  import icontract
  
  import tests.error
  
  
  class TestNoneSpecified(unittest.TestCase):
      def test_that_it_works(self) -> None:
          @icontract.require(lambda x: x > 0)
          def some_func(x: int) -> None:
              pass
  
          violation_error = None  # type: Optional[icontract.ViolationError]
          try:
              some_func(x=-1)
          except icontract.ViolationError as err:
              violation_error = err
  
          assert violation_error is not None
          self.assertEqual('x > 0: x was -1', tests.error.wo_mandatory_location(str(violation_error)))
  
  
  class TestSpecifiedAsFunction(unittest.TestCase):
      def test_lambda(self) -> None:
          @icontract.require(lambda x: x > 0, error=lambda x: ValueError("x must be positive: {}".format(x)))
          def some_func(x: int) -> None:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('x must be positive: -1', str(value_error))
  
      def test_separate_function(self) -> None:
          def error_func(x: int) -> ValueError:
              return ValueError("x must be positive: {}".format(x))
  
          @icontract.require(lambda x: x > 0, error=error_func)
          def some_func(x: int) -> None:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('x must be positive: -1', str(value_error))
  
      def test_separate_method(self) -> None:
          class Errorer:
              def error_func(self, x: int) -> ValueError:
                  return ValueError("x must be positive: {}".format(x))
  
          errorer = Errorer()
  
          @icontract.require(lambda x: x > 0, error=errorer.error_func)
          def some_func(x: int) -> None:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('x must be positive: -1', str(value_error))
  
      def test_report_if_result_is_not_base_exception(self) -> None:
          @icontract.require(lambda x: x > 0, error=lambda x: "x must be positive")  # type: ignore
          def some_func(x: int) -> None:
              pass
  
          type_error = None  # type: Optional[TypeError]
          try:
              some_func(x=-1)
          except TypeError as err:
              type_error = err
  
          assert type_error is not None
          self.assertRegex(
              str(type_error),
              r"^The exception returned by the contract's error <function .*> does not inherit from BaseException\.$")
  
  
  class TestSpecifiedAsType(unittest.TestCase):
      def test_valid_exception(self) -> None:
          @icontract.require(lambda x: x > 0, error=ValueError)
          def some_func(x: int) -> None:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('x > 0: x was -1', tests.error.wo_mandatory_location(str(value_error)))
  
  
  class TestSpecifiedAsInstance(unittest.TestCase):
      def test_valid_exception(self) -> None:
          @icontract.require(lambda x: x > 0, error=ValueError("negative x"))
          def some_func(x: int) -> None:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('negative x', str(value_error))
  
      def test_repeated_raising(self) -> None:
          @icontract.require(lambda x: x > 0, error=ValueError("negative x"))
          def some_func(x: int) -> None:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('negative x', str(value_error))
  
          # Repeat
          value_error = None
          try:
              some_func(x=-1)
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertEqual('negative x', str(value_error))
  
  
  class TestSpecifiedAsInvalidType(unittest.TestCase):
      def test_in_precondition(self) -> None:
          class A:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
  
              @icontract.require(lambda x: x > 0, error=A)  # type: ignore
              def some_func(x: int) -> None:
                  pass
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertRegex(
              str(value_error), r"The error of the contract is given as a type, "
              r"but the type does not inherit from BaseException: <class .*\.A'>")
  
      def test_in_postcondition(self) -> None:
          class A:
              pass
  
          value_error = None  # type: Optional[ValueError]
          try:
  
              @icontract.ensure(lambda result: result > 0, error=A)  # type: ignore
              def some_func() -> int:
                  return -1
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertRegex(
              str(value_error), r"The error of the contract is given as a type, "
              r"but the type does not inherit from BaseException: <class .*\.A'>")
  
      def test_in_invariant(self) -> None:
          value_error = None  # type: Optional[ValueError]
          try:
  
              class A:
                  pass
  
              @icontract.invariant(lambda self: self.x > 0, error=A)  # type: ignore
              class B:
                  def __init__(self) -> None:
                      self.x = -1
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertRegex(
              str(value_error), r"The error of the contract is given as a type, "
              r"but the type does not inherit from BaseException: <class .*\.A'>")
  
  
  class TestSpecifiedAsInstanceOfInvalidType(unittest.TestCase):
      def test_in_precondition(self) -> None:
          class A:
              def __init__(self, msg: str) -> None:
                  self.msg = msg
  
          value_error = None  # type: Optional[ValueError]
          try:
  
              @icontract.require(lambda x: x > 0, error=A("something went wrong"))  # type: ignore
              def some_func(x: int) -> None:
                  pass
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertRegex(
              str(value_error), r"^The error of the contract must be either a callable \(a function or a method\), "
              r"a class \(subclass of BaseException\) or an instance of BaseException, "
              r"but got: <.*\.A object at 0x.*>$")
  
      def test_in_postcondition(self) -> None:
          class A:
              def __init__(self, msg: str) -> None:
                  self.msg = msg
  
          value_error = None  # type: Optional[ValueError]
          try:
  
              @icontract.ensure(lambda result: result > 0, error=A("something went wrong"))  # type: ignore
              def some_func() -> int:
                  return -1
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertRegex(
              str(value_error), r"^The error of the contract must be either a callable \(a function or a method\), "
              r"a class \(subclass of BaseException\) or an instance of BaseException, "
              r"but got: <.*\.A object at 0x.*>$")
  
      def test_in_invariant(self) -> None:
          class A:
              def __init__(self, msg: str) -> None:
                  self.msg = msg
  
          value_error = None  # type: Optional[ValueError]
          try:
  
              @icontract.invariant(lambda self: self.x > 0, error=A("something went wrong"))  # type: ignore
              class B:
                  def __init__(self) -> None:
                      self.x = -1
          except ValueError as err:
              value_error = err
  
          assert value_error is not None
          self.assertRegex(
              str(value_error), r"^The error of the contract must be either a callable \(a function or a method\), "
              r"a class \(subclass of BaseException\) or an instance of BaseException, "
              r"but got: <.*\.A object at 0x.*>$")
  
  
  if __name__ == '__main__':
      unittest.main()
  