Example #1
0
def proxy_for_class(typ: Type, varname: str,
                    meet_class_invariants: bool) -> object:
    # if the class has data members, we attempt to create a concrete instance with
    # symbolic members; otherwise, we'll create an object proxy that emulates it.
    obj = proxy_class_as_concrete(typ, varname)
    if obj is _MISSING:
        debug('Creating', typ, 'as an independent proxy class')
        obj = make_fake_object(typ, varname)
    else:
        debug('Creating', typ, 'with symbolic attribute assignments')
    class_conditions = _CALLTREE_PARSER.get().get_class_conditions(typ)
    # symbolic custom classes may assume their invariants:
    if meet_class_invariants and class_conditions is not None:
        for inv_condition in class_conditions.inv:
            if inv_condition.evaluate is None:
                continue
            isok = False
            with ExceptionFilter() as efilter:
                isok = inv_condition.evaluate({'self': obj})
            if efilter.user_exc:
                raise IgnoreAttempt(
                    f'Class proxy could not meet invariant "{inv_condition.expr_source}" on '
                    f'{varname} (proxy of {typ}) because it raised: {repr(efilter.user_exc[0])}'
                )
            else:
                if efilter.ignore or not isok:
                    raise IgnoreAttempt('Class proxy did not meet invariant ',
                                        inv_condition.expr_source)
    return obj
Example #2
0
 def check_deferred_assumptions(self,
                                exc: Optional[Exception] = None) -> None:
     if isinstance(exc, NotDeterministic):
         # We won't be able to check deferred assumptions if our search tree isn't
         # stable.
         return
     for description, checker in self._deferred_assumptions:
         if not prefer_true(checker()):
             raise IgnoreAttempt("deferred assumption failed: " +
                                 description)
Example #3
0
def describe_behavior(
        fn: Callable, args: inspect.BoundArguments) -> Tuple[object, Optional[Exception]]:
    with ExceptionFilter() as efilter:
        ret = fn(*args.args, **args.kwargs)
        return (ret, None)
    if efilter.user_exc is not None:
        debug('user-level exception found', *efilter.user_exc)
        return (None, efilter.user_exc[0])
    if efilter.ignore:
        return (None, IgnoreAttempt())
    assert False
Example #4
0
    def detach_path(self, exc: Optional[Exception] = None) -> None:
        """
        Mark the current path exhausted.

        Also verifies all deferred assumptions.
        After detaching, the space may continue to be used (for example, to print
        realized symbolics).
        """
        if isinstance(exc, NotDeterministic):
            # NotDeterministic is a user-reportable error, but it isn't valid to try
            # and use the statespace after it's detected
            return
        for description, checker in self._deferred_assumptions:
            if not prefer_true(checker()):
                raise IgnoreAttempt("deferred assumption failed: " +
                                    description)
        with NoTracing():
            assert self._search_position.is_stem()
            node = self._search_position.grow_into(DeatchedPathNode())
            assert node.child.is_stem()
            self.choices_made.append(node)
            self._search_position = node.child
Example #5
0
 def check_deferred_assumptions(self) -> None:
     for description, checker in self._deferred_assumptions:
         if not checker():
             raise IgnoreAttempt('deferred assumption failed: ' +
                                 description)
Example #6
0
 def check_deferred_assumptions(self) -> None:
     for description, checker in self._deferred_assumptions:
         if not prefer_true(checker()):
             raise IgnoreAttempt("deferred assumption failed: " +
                                 description)