def test_class_patching_is_undone(self) -> None:
# CrossHair does a lot of monkey matching of classes
# with contracts. Ensure that gets undone.
original_container = ShippingContainer.__dict__.copy()
original_overloaded = OverloadedContainer.__dict__.copy()
run_checkables(analyze_class(OverloadedContainer))
for k, v in original_container.items():
self.assertIs(ShippingContainer.__dict__[k], v)
for k, v in original_overloaded.items():
self.assertIs(OverloadedContainer.__dict__[k], v)
def check_post_err(
fn: Callable, optionset: AnalysisOptionSet = AnalysisOptionSet()
) -> ComparableLists:
local_opts = AnalysisOptionSet(max_iterations=20)
options = local_opts.overlay(optionset)
states = [m.state for m in run_checkables(analyze_function(fn, options))]
return (states, [MessageType.POST_ERR])
def check_fail(
fn: Callable, optionset: AnalysisOptionSet = AnalysisOptionSet()
) -> ComparableLists:
local_opts = AnalysisOptionSet(max_iterations=40, per_condition_timeout=5)
options = local_opts.overlay(optionset)
states = [m.state for m in run_checkables(analyze_function(fn, options))]
return (states, [MessageType.POST_FAIL])
def check_messages(checkables: Iterable[Checkable], **kw) -> ComparableLists:
msgs = run_checkables(checkables)
if kw.get("state") != MessageType.CONFIRMED:
# Normally, ignore confirmation messages:
msgs = [m for m in msgs if m.state != MessageType.CONFIRMED]
else:
# When we want CONFIRMED, take the message with the worst status:
msgs = [max(msgs, key=lambda m: m.state)]
default_msg = AnalysisMessage(MessageType.CANNOT_CONFIRM, "", "", 0, 0, "")
msg = msgs[0] if msgs else replace(default_msg)
fields = (
"state",
"message",
"filename",
"line",
"column",
"traceback",
"test_fn",
"condition_src",
)
for k in fields:
if k not in kw:
default_val = getattr(default_msg, k)
msg = replace(msg, **{k: default_val})
kw[k] = default_val
if msgs:
msgs[0] = msg
return (msgs, [AnalysisMessage(**kw)])
def test_icontract_class(self):
messages = run_checkables(
analyze_class(
IcontractB,
DEFAULT_OPTIONS.overlay(
analysis_kind=[AnalysisKind.icontract]),
))
messages = {(m.state, m.line, m.message)
for m in messages if m.state != MessageType.CONFIRMED}
self.assertEqual(
messages,
{
(
MessageType.POST_FAIL,
114,
'"@icontract.invariant(lambda self: self.x > 0)" yields false '
"when calling break_parent_invariant(self = instance of B(10))",
),
(
MessageType.POST_FAIL,
117,
'"@icontract.invariant(lambda self: self.x < 100)" yields false '
"when calling break_my_invariant(self = instance of B(10))",
),
},
)
def check_unknown(
fn: Callable, optionset: AnalysisOptionSet = AnalysisOptionSet()
) -> ComparableLists:
local_opts = AnalysisOptionSet(max_iterations=40, per_condition_timeout=3)
options = local_opts.overlay(optionset)
messages = [(m.state, m.message, m.traceback)
for m in run_checkables(analyze_function(fn, options))]
return (messages, [(MessageType.CANNOT_CONFIRM, "Not confirmed.", "")])
def check_ok(
fn: Callable, optionset: AnalysisOptionSet = AnalysisOptionSet()
) -> ComparableLists:
local_opts = AnalysisOptionSet(per_condition_timeout=5)
options = local_opts.overlay(optionset)
messages = [
message for message in run_checkables(analyze_function(fn, options))
if message.state != MessageType.CONFIRMED
]
return (messages, [])
def check_exec_err(
fn: Callable, message_prefix="", optionset: AnalysisOptionSet = AnalysisOptionSet()
) -> ComparableLists:
local_opts = AnalysisOptionSet(max_iterations=20, per_condition_timeout=5)
options = local_opts.overlay(optionset)
messages = run_checkables(analyze_function(fn, options))
if all(m.message.startswith(message_prefix) for m in messages):
return ([m.state for m in messages], [MessageType.EXEC_ERR])
else:
return (
[(m.state, m.message) for m in messages],
[(MessageType.EXEC_ERR, message_prefix)],
)
def check_states(
fn: Callable, optionset: AnalysisOptionSet = AnalysisOptionSet()
) -> Set[MessageType]:
local_opts = AnalysisOptionSet(max_iterations=40, per_condition_timeout=5)
options = local_opts.overlay(optionset)
return set([m.state for m in run_checkables(analyze_function(fn, options))])
