def test_onearg_and_default(self):
"""Tests if reassign works correctly with one arg and default
"""
varargs = (12,)
kwargs = {}
method = getattr(self.foo,'f_onearg_and_default')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(var_dict['default'] == 1)
self.assert_(len(var_dict) == 2)
var_dict = reassign_function_arguments(method, (12, 13), kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(var_dict['default'] == 13)
self.assert_(len(var_dict) == 2)
def test_onearg_and_default(self):
"""Tests if reassign works correctly with one arg and default
"""
varargs = (12, )
kwargs = {}
method = getattr(self.foo, 'f_onearg_and_default')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(var_dict['default'] == 1)
self.assert_(len(var_dict) == 2)
var_dict = reassign_function_arguments(method, (12, 13), kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(var_dict['default'] == 13)
self.assert_(len(var_dict) == 2)
def test_named_params(self):
"""tests calling f by naming all arguments"""
varargs = ()
kwargs = {'arg1' : "arg1_val", 'default' : "default_val"}
method = getattr(self.foo,'f_onearg_and_default')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assertEquals(kwargs, var_dict)
def test_named_params(self):
"""tests calling f by naming all arguments"""
varargs = ()
kwargs = {'arg1': "arg1_val", 'default': "default_val"}
method = getattr(self.foo, 'f_onearg_and_default')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assertEquals(kwargs, var_dict)
def test_noarg(self):
"""Tests if reassign works correctly with no args
"""
varargs = ()
kwargs = {}
method = getattr(self.foo,'f_noarg')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict == {})
def test_noarg(self):
"""Tests if reassign works correctly with no args
"""
varargs = ()
kwargs = {}
method = getattr(self.foo, 'f_noarg')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict == {})
def test_keyword(self):
"""Tests if reassign works correctly with a keyword arg
"""
varargs = ()
kwargs = {'default' : 12}
method = getattr(self.foo,'f_default')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['default'] == 12)
self.assert_(len(var_dict) == 1)
def test_onearg(self):
"""Tests if reassign works correctly with one arg
"""
varargs = (12, )
kwargs = {}
method = getattr(self.foo, 'f_onearg')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(len(var_dict) == 1)
def test_keyword(self):
"""Tests if reassign works correctly with a keyword arg
"""
varargs = ()
kwargs = {'default': 12}
method = getattr(self.foo, 'f_default')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['default'] == 12)
self.assert_(len(var_dict) == 1)
def test_onearg(self):
"""Tests if reassign works correctly with one arg
"""
varargs = (12,)
kwargs = {}
method = getattr(self.foo,'f_onearg')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(len(var_dict) == 1)
def test_twoargs(self):
"""Tests if reassign works correctly with two args
"""
varargs = (12, 13)
kwargs = {}
method = getattr(self.foo,'f_twoargs')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(var_dict['arg2'] == 13)
self.assert_(len(var_dict) == 2)
def test_twoargs(self):
"""Tests if reassign works correctly with two args
"""
varargs = (12, 13)
kwargs = {}
method = getattr(self.foo, 'f_twoargs')
var_dict = reassign_function_arguments(method, varargs, kwargs)
self.assert_(var_dict['arg1'] == 12)
self.assert_(var_dict['arg2'] == 13)
self.assert_(len(var_dict) == 2)
def before(self, wobj, context, *args, **kwargs):
"""Before method
"""
met_name = context['method_name']
classname = context['__class__'].__name__
method = self._get_base_method(wobj, met_name)
self.log_device.write("Calling %s (%s) \n" % (met_name, classname))
self.log_device.write("\twith values : \n")
call_dict = reassign_function_arguments(method, args, kwargs)
for var, val in call_dict.items():
self.log_device.write('\t\t "%s" = %r\n' % (repr(var), val))
def before(self, wobj, context, *args, **kwargs):
"""Before method"""
self.base_info(wobj, context)
write = self.output.write
if self.config.parameters:
write("(")
method = self._get_base_method(wobj, context['method_name'])
call_dict = reassign_function_arguments(method, args, kwargs)
write(', '.join(['%s=%r' % (var, val)
for var, val in call_dict.items()]))
write(")")
write('\n')
def before(self, wobj, context, *args, **kwargs):
"""Before method
"""
met_name = context['method_name']
classname = context['__class__'].__name__
property_func = context['property_func']
method = self._get_base_method(wobj, met_name, property_func)
self.log_device.write("[%s] Calling %s (%s) \n" % (
self._log_date_time_string(), met_name, classname))
self.log_device.write(
"[%s]\twith values : \n" % self._log_date_time_string())
call_dict = reassign_function_arguments(method, args, kwargs)
for var, val in call_dict.items():
self.log_device.write('[%s]\t\t "%s" = %r\n' % (
self._log_date_time_string(), repr(var), val))
def after(self, wobj, context, *args, **kwargs):
"""
self : aspect instance
wobj : the weaved object instance
global_dict : the wrapped_func globals dict (f.func_globals)
ret_v : the return value of the wrapped method
exec_excpt : the exception raised by the wrapped method or None
if no exception has been raised
"""
met_name = context['method_name']
ret_v = context['ret_v']
exec_excpt = context['exception']
base_method = self._get_base_method(wobj, met_name)
local_dict = {}
method_dict = base_method.im_func.func_globals
local_dict.update(method_dict)
dummy, post, inv, holder = self._get_definitions(wobj, met_name)
local_dict.update(reassign_function_arguments(
base_method, args, kwargs))
local_dict['self'] = wobj
local_dict['__return__'] = ret_v
local_dict['__old__'] = holder
local_dict['exists'] = exists
local_dict['forall'] = forall
# First check invariants
##########################################################
# We use __aspecting_inv__ a bit as a lock() to prevent
# infinite loops if method calls are done on self in
# invariant conditions
##########################################################
# Skip invariant checks if we're already in one of those
if '__aspecting_inv__' not in wobj.__dict__:
wobj.__dict__['__aspecting_inv__'] = True
# self._check_invariants(wobj, local_dict)
if inv is not None:
self._check_conditions(inv, local_dict, "inv")
del wobj.__dict__['__aspecting_inv__']
# Check post-conditions if no exception has been raised
if exec_excpt is None:
# self._check_post_conditions(wobj, local_dict)
if post is not None:
self._check_conditions(post, local_dict, "post")
def before(self, wobj, context, *args, **kwargs):
"""
self : aspect instance
wobj : the weaved object instance
global_dict : the wrapped_func globals dict (f.func_globals)
"""
met_name = context['method_name']
base_method = self._get_base_method(wobj, met_name)
local_dict = {}
method_dict = base_method.im_func.func_globals
local_dict.update(method_dict)
pre, dummy, inv, holder = self._get_definitions(wobj, met_name)
local_dict.update(reassign_function_arguments(base_method,
args, kwargs))
local_dict['self'] = wobj
local_dict['exists'] = exists
local_dict['forall'] = forall
# Memorize state of variables which are needed with __old__ in post
# conditions.
# for var in holder.memo_list:
# holder.set(var, eval(var, local_dict))
for var in holder.iterkeys():
holder[var] = eval(var, local_dict)
# First check invariants
##########################################################
# We use __aspecting_inv__ a bit as a lock() to prevent
# infinite loops if method calls are done on self in
# invariant conditions
##########################################################
# Skip invariant checks if we're already in one of those
if '__aspecting_inv__' not in wobj.__dict__:
wobj.__dict__['__aspecting_inv__'] = True
if inv is not None:
self._check_conditions(inv, local_dict, "inv")
# self._check_invariants(wobj, local_dict)
del wobj.__dict__['__aspecting_inv__']
# Then check pre-conditions
# self._check_pre_conditions(wobj, local_dict)
if pre is not None:
self._check_conditions(pre, local_dict, "pre")
