def test_operator_dispatch_2(): #IGNORE:C01111 msg = 'Test Interpreter: handling of operators with unknown Float values.' #skip_test(msg) print msg from freeode.interpreter import Interpreter, IFloat, istype from freeode.ast import (NodeOpInfix2, NodeOpPrefix1, NodeFuncCall, RoleVariable) from freeode.util import func #, aa_make_tree intp = Interpreter() val_2 = IFloat() val_2.__siml_role__ = RoleVariable val_3 = IFloat() val_3.__siml_role__ = RoleVariable op_sub = NodeOpInfix2('-', [val_2, val_3]) res = intp.eval(op_sub) print res assert isinstance(res, NodeFuncCall) assert res.function is func(IFloat.__sub__) assert istype(res, IFloat) op_neg = NodeOpPrefix1('-', [val_2]) res = intp.eval(op_neg) print res assert isinstance(res, NodeFuncCall) assert res.function is func(IFloat.__neg__) assert istype(res, IFloat)
def test_determine_result_role_1(): #IGNORE:C01111 msg = 'Test determine_result_role: ' #skip_test(msg) print msg from freeode.interpreter import IFloat, determine_result_role from freeode.ast import RoleConstant, RoleParameter, RoleVariable #some constants c_1 = IFloat() c_1.__siml_role__ = RoleConstant c_2 = IFloat() c_2.__siml_role__ = RoleConstant #some parameters p_1 = IFloat() p_1.__siml_role__ = RoleParameter p_2 = IFloat() p_2.__siml_role__ = RoleParameter #some variables v_1 = IFloat() v_1.__siml_role__ = RoleVariable v_2 = IFloat() v_2.__siml_role__ = RoleVariable #determine the most variable role among the arguments assert issubclass(determine_result_role((c_1, p_1, v_1), {'a':c_2, 'b':p_2, 'c':v_2, }), RoleVariable) assert determine_result_role((c_1, p_1), {'a':c_2, 'b':p_2}) == RoleParameter assert determine_result_role((c_1,), {'a':c_2}) == RoleConstant
def test_function_call_unknown_arguments_1(): #IGNORE:C01111 msg = 'Test expression evaluation (calling built in functions), unknown arguments' #skip_test(msg) print msg from freeode.interpreter import (IModule, ExecutionEnvironment, Interpreter, signature, IFloat, RoleVariable, istype, test_allknown) from freeode.ast import NodeFuncCall, NodeIdentifier from freeode.util import aa_make_tree import math #create module where the function lives mod = IModule() #create sqrt function that can be called from Siml @signature([IFloat], IFloat) def sqrt(x): test_allknown(x) return IFloat(math.sqrt(x.value)) #put function into module mod.sqrt = sqrt print print 'Module where function is located: --------------------------------------------' #print aa_make_tree(mod) #create environment for lookup of variables (stack frame) env = ExecutionEnvironment() env.global_scope = mod #create visitor for evaluating the expression intp = Interpreter() intp.push_environment(env) #create a Siml value as function argument val_1 = IFloat() val_1.__siml_role__ = RoleVariable #create function call with unkown argument call = NodeFuncCall(NodeIdentifier('sqrt'), [val_1], {}) #evaluate the function call ret_val = intp.eval(call) print print 'Result object: --------------------------------------------------------------' print aa_make_tree(ret_val) #evaluating a function call with unknown arguments must return a function call assert isinstance(ret_val, NodeFuncCall) assert istype(ret_val, IFloat)
def test_expression_evaluation_5(): #IGNORE:C01111 msg = \ ''' Test expression evaluation (returning of partially evaluated expression when accessing variables) ''' #skip_test(msg) print msg from freeode.ast import RoleVariable, NodeFuncCall from freeode.interpreter import (IModule, IFloat, ExecutionEnvironment, Interpreter, istype) import freeode.simlparser as simlparser from freeode.util import func #, aa_make_tree #parse the expression ps = simlparser.Parser() ex = ps.parseExpressionStr('a + 2*2') # print # print 'AST (parser output): -----------------------------------------------------------' # print aa_make_tree(ex) #create module where name lives mod = IModule() #create attribute 'a' with no value val_2 = IFloat() val_2.__siml_role__ = RoleVariable mod.a = val_2 # print # print 'Module where variable is located: --------------------------------------------' # print aa_make_tree(mod) #create environment for lookup of variables (stack frame) env = ExecutionEnvironment() env.global_scope = mod #interpret the expression intp = Interpreter() intp.environment = env res = intp.eval(ex) # print # print 'Result object - should be an unevaluated expression: --------------------------------------------------------------' # print aa_make_tree(res) assert isinstance(res, NodeFuncCall) assert res.function is func(IFloat.__add__) assert istype(res, IFloat)
def test_function_call_unknown_arguments_2(): #IGNORE:C01111 msg = 'Test Interpreter: call real library function with unknown argument' #skip_test(msg) print msg from freeode.interpreter import Interpreter, IFloat, istype from freeode.ast import NodeFuncCall, NodeIdentifier, RoleVariable #create the interpreter intp = Interpreter() #IGNORE:W0612 intp.create_test_module_with_builtins() #create a Siml value as function argument val_1 = IFloat() val_1.__siml_role__ = RoleVariable #create function call with unkown argument call = NodeFuncCall(NodeIdentifier('sqrt'), [val_1], {}) #interpret call ret_val = intp.eval(call) #evaluating a function call with unknown arguments must return a function call assert isinstance(ret_val, NodeFuncCall) assert istype(ret_val, IFloat)
def test_determine_result_role_2(): #IGNORE:C01111 msg = 'Test determine_result_role: errors' #skip_test(msg) print msg from freeode.interpreter import IFloat, determine_result_role from freeode.ast import (RoleConstant, RoleParameter, RoleVariable, RoleUnkown) #unknown role u = IFloat() u.__siml_role__ = RoleUnkown #some constants c_1 = IFloat() c_1.__siml_role__ = RoleConstant c_2 = IFloat() c_2.__siml_role__ = RoleConstant #some parameters p_1 = IFloat() p_1.__siml_role__ = RoleParameter p_2 = IFloat() p_2.__siml_role__ = RoleParameter #some variables v_1 = IFloat() v_1.__siml_role__ = RoleVariable v_2 = IFloat() v_2.__siml_role__ = RoleVariable #one argument with RoleUnknown - should raise exception def raise_1(): determine_result_role((c_1, p_1, v_1, u), {'a':c_2, 'b':p_2, 'c':v_2, }) assert_raises(ValueError, None, raise_1) #one argument with RoleUnknown - should raise exception def raise_2(): determine_result_role((c_1, p_1), {'a':c_2, 'b':p_2, 'u':u}) assert_raises(ValueError, None, raise_2) #one argument with RoleUnknown - should raise exception def raise_3(): determine_result_role((c_1, u), {'a':c_2}) assert_raises(ValueError, None, raise_3)