def make_fake_object(statespace: StateSpace, cls: type,
varname: str) -> object:
constructor = get_smt_proxy_type(cls)
debug(constructor)
try:
proxy = constructor()
except TypeError as e:
# likely the type has a __new__ that expects arguments
raise CrosshairUnsupported(f'Unable to proxy {name_of_type(cls)}: {e}')
for name, typ in get_type_hints(cls).items():
origin = getattr(typ, '__origin__', None)
if origin is Callable:
continue
value = proxy_for_type(typ, statespace,
varname + '.' + name + statespace.uniq())
object.__setattr__(proxy, name, value)
return proxy
def gen_args(sig: inspect.Signature,
statespace: StateSpace) -> inspect.BoundArguments:
args = sig.bind_partial()
for param in sig.parameters.values():
smt_name = param.name + statespace.uniq()
proxy_maker = lambda typ, **kw: proxy_for_type(
typ, statespace, smt_name, allow_subtypes=True, **kw)
has_annotation = (param.annotation != inspect.Parameter.empty)
value: object
if param.kind == inspect.Parameter.VAR_POSITIONAL:
if has_annotation:
varargs_type = List[param.annotation] # type: ignore
value = proxy_maker(varargs_type)
else:
value = proxy_maker(List[Any])
elif param.kind == inspect.Parameter.VAR_KEYWORD:
if has_annotation:
varargs_type = Dict[str, param.annotation] # type: ignore
value = cast(dict, proxy_maker(varargs_type))
# Using ** on a dict requires concrete string keys. Force
# instiantiation of keys here:
value = {k.__str__(): v for (k, v) in value.items()}
else:
value = proxy_maker(Dict[str, Any])
else:
is_self = param.name == 'self'
# Object parameters should meet thier invariants iff they are not the
# class under test ("self").
meet_class_invariants = not is_self
allow_subtypes = not is_self
if has_annotation:
value = proxy_for_type(param.annotation, statespace, smt_name,
meet_class_invariants, allow_subtypes)
else:
value = proxy_for_type(cast(type, Any), statespace, smt_name,
meet_class_invariants, allow_subtypes)
debug('created proxy for', param.name, 'as type:', type(value))
args.arguments[param.name] = value
return args
def __ch_forget_contents__(self, space: StateSpace):
cls = self.__ch_pytype__()
clean = proxy_for_type(cls, space, space.uniq())
for name, val in self.__dict__.items():
self.__dict__[name] = clean.__dict__[name]
