From 99c062c028c7f4e94fb38cde50772cfd3ea5ad3b Mon Sep 17 00:00:00 2001 From: Derick Huth Date: Thu, 24 Sep 2015 11:34:04 -0600 Subject: v0.2.1 --- test-chill/unit-tests/test__cpp_validate_env.py | 377 ------------------------ 1 file changed, 377 deletions(-) delete mode 100644 test-chill/unit-tests/test__cpp_validate_env.py (limited to 'test-chill/unit-tests/test__cpp_validate_env.py') diff --git a/test-chill/unit-tests/test__cpp_validate_env.py b/test-chill/unit-tests/test__cpp_validate_env.py deleted file mode 100644 index e0225cd..0000000 --- a/test-chill/unit-tests/test__cpp_validate_env.py +++ /dev/null @@ -1,377 +0,0 @@ -import ast -import functools -import itertools -import pylang.debug -import random -import struct -import unittest - -import testchill -import testchill._cpp_validate_env as validate_env -import testchill.cpp_validate -import testchill.util - -## Support functions ## -class Point(object): - def __init__(self, x, y): - self.x = x - self.y = y - -def _compile_and_run(expr, target_type, bindings): - t = ast.fix_missing_locations(ast.Expression(expr.compile_expr(target_type))) - return eval(compile(t, '', 'eval'), bindings) - -def _compile_and_invoke(expr, target_type, bindings, args): - t = ast.fix_missing_locations(ast.Expression(expr.compile_expr(target_type))) - return (eval(compile(t, '', 'eval'), bindings))(*args) - -def _expr_test(tc, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value): - freevars = expr.getfreevars(fv_bindings) - value = _compile_and_run(expr, target_type, rt_bindings) - tc.assertEqual(exp_freevars, freevars) - tc.assertEqual(exp_value, value) - tc.assertEqual(target_type, type(value)) - -def _expr_test_list(tc, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value): - freevars = expr.getfreevars(fv_bindings) - value = _compile_and_run(expr, target_type, rt_bindings) - tc.assertEqual(exp_freevars, freevars) - tc.assertEqual(exp_value, value) - tc.assertEqual(list, type(value)) - -def _expr_test_invoke(tc, expr, fv_bindings, rt_bindings, target_type, exp_freevars, invoke_args, exp_value): - freevars = expr.getfreevars(fv_bindings) - value = _compile_and_invoke(expr, target_type, rt_bindings, invoke_args) - tc.assertEqual(exp_freevars, freevars) - tc.assertEqual(exp_value, value) - tc.assertEqual(target_type.exprtype, type(value)) - -def lambdatype(param_types, etype): - return validate_env._pylambdatype(param_types, etype) - -def arraytype(dims, etype): - return validate_env._pyarraytype(dims, etype) - - -## Test case class ## -class Test_CppValidateEnv(unittest.TestCase): - def setUp(self): - ### data for the abstract syntax tree ### - _const_4 = validate_env._ConstantExpr('4') - _const_3 = validate_env._ConstantExpr('3') - _const_2 = validate_env._ConstantExpr('2') - _const_0 = validate_env._ConstantExpr('0') - _name_x = validate_env._NameExpr('x') - _name_y = validate_env._NameExpr('y') - _name_p = validate_env._NameExpr('p') - _name_pow = validate_env._NameExpr('pow') - _attr_px = validate_env._AttributeExpr(_name_p, 'x') - _attr_py = validate_env._AttributeExpr(_name_p, 'y') - _add_3_2 = validate_env._BinExpr(_const_3, '+', _const_2) - _add_x_2 = validate_env._BinExpr(_name_x, '+', _const_2) - _pow_x_2 = validate_env._BinExpr(_name_x, '**', _const_2) - - _name_i = validate_env._NameExpr('i') - _lambda_i = validate_env._LambdaExpr(['i'],_name_i) - - _name_j = validate_env._NameExpr('j') - _const_10 = validate_env._ConstantExpr('10') - _mul_i_10 = validate_env._BinExpr(_name_i, '*', _const_10) - _add_mul_i_10_j = validate_env._BinExpr(_mul_i_10, '+', _name_j) - _lambda_ij = validate_env._LambdaExpr(['i','j'],_add_mul_i_10_j) - - self._ConstantExpr_test_data = [ - (('3',), set(), dict(), int, set(), int(3)), - (('3',), set(), dict(), float, set(), float(3)) - ] - self._NameExpr_test_data = [ - (('x',), set(), {'x':3}, int, {'x'}, int(3)), - (('x',), {'x'}, {'x':3}, int, set(), int(3)) - ] - self._AttributeExpr_test_data = [ - ((validate_env._NameExpr('p'),'x'), set(), {'p':Point(3,0)}, int, {'p'}, int(3)), - ((validate_env._NameExpr('p'),'x'), {'p'}, {'p':Point(3,0)}, int, set(), int(3)) - ] - self._BinExpr_test_data = [ - ((_const_3, '+', _const_2), set(), dict(), int, set(), int(5)), - ((_const_3, '+', _const_2), set(), dict(), float, set(), float(5)), - ((_name_x, '+', _const_2), set(), {'x':3}, int, {'x'}, int(5)), - ((_name_x, '+', _const_2), {'x'}, {'x':3}, int, set(), int(5)), - ((_const_3, '+', _name_x), set(), {'x':2}, int, {'x'}, int(5)), - ((_const_3, '+', _name_x), {'x'}, {'x':2}, int, set(), int(5)), - ((_const_3, '-', _const_2), set(), dict(), int, set(), int(1)), - ((_const_3, '*', _const_2), set(), dict(), int, set(), int(6)), - ((_const_3, '/', _const_2), set(), dict(), int, set(), int(1)), - ((_const_3, '**', _const_2), set(), dict(), int, set(), int(9)) - ] - self._UnaryExpr_test_data = [ - (('-', _const_3), set(), dict(), int, set(), int(-3)), - (('-', _add_3_2), set(), dict(), int, set(), int(-5)), - (('-', _add_x_2), set(), {'x':3}, int, {'x'}, int(-5)), - (('-', _add_x_2), {'x'}, {'x':3}, int, set(), int(-5)) - ] - self._LambdaExpr_test_data = [ - (([],_const_3), set(), dict(), lambdatype([],int), set(), tuple(), int(3)), - (([],_name_x), set(), {'x':3}, lambdatype([],int), {'x'}, tuple(), int(3)), - ((['x'],_pow_x_2), set(), dict(), lambdatype([int],int), set(), (int(4),), int(16)) - ] - self._InvokeExpr_test_data = [ - ((_name_pow,[_const_3, _const_2]), set(), dict(), int, {'pow'}, int(9)), - ] - self._MatrixGenerator_test_data = [ - (([_const_2],_lambda_i), set(), {'_pyitertools': itertools}, arraytype([None],int), set(), [0, 1]), - (([None],_lambda_i), set(), {'_pyitertools': itertools}, arraytype([_const_2],int), set(), [0, 1]), - (([_const_2,_const_3],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([_const_2,_const_3], int), set(), [0, 1, 2, 10, 11, 12]), - (([_const_2,_const_3],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([None,None], int), set(), [0, 1, 2, 10, 11, 12]), - (([_const_2,None],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([None,_const_3], int), set(), [0, 1, 2, 10, 11, 12]), - (([None,_const_3],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([_const_2,None], int), set(), [0, 1, 2, 10, 11, 12]), - (([None,None],_lambda_ij), set(), {'_pyitertools': itertools}, arraytype([_const_2,_const_3], int), set(), [0, 1, 2, 10, 11, 12]), - (([_name_x],_lambda_i), set(), {'_pyitertools': itertools, 'x':2}, arraytype([None],int), {'x'}, [0, 1]), - (([None],_lambda_i), set(), {'_pyitertools': itertools, 'x':2}, arraytype([_name_x],int), set(), [0, 1]), - ] - self._RandomExpr_test_state = random.getstate() - self._RandomExpr_test_data = [ - ((_const_0,_const_4), set(), {'_pyrandom': random}, int, set(), int(random.random()*4)), - ((_const_0,_name_x), set(), {'_pyrandom': random, 'x':4}, int, {'x'}, int(random.random()*4)), - ((_name_x,_const_4), set(), {'_pyrandom': random, 'x':0}, int, {'x'}, int(random.random()*4)), - ] - ### data for data generating ### - _name_ambn = validate_env._NameExpr('ambn') - _name_an = validate_env._NameExpr('an') - _name_bm = validate_env._NameExpr('bm') - _name_even2 = validate_env._NameExpr('evendist2') - _lambda_ij_0 = validate_env._LambdaExpr(['i','j'],_const_0) - _matrix_2_an_ambn_even2 = validate_env._MatrixGenerator([_name_an,_name_ambn],_name_even2) - _matrix_2_ambn_bm_even2 = validate_env._MatrixGenerator([_name_ambn,_name_bm],_name_even2) - _matrix_2_an_bm_lambda_ij_0 = validate_env._MatrixGenerator([_name_an,_name_bm],_lambda_ij_0) - _add_an_bm = validate_env._BinExpr(_name_an, '+', _name_bm) - _int_type = validate_env._CppPrimitiveType.get_from_cppname('int') - _float_type = validate_env._CppPrimitiveType.get_from_cppname('float') - _float_ptr_type = validate_env._CppPointerType(_float_type) - _param_A = validate_env._Parameter('A', _float_ptr_type,'in', _matrix_2_an_ambn_even2) - _param_B = validate_env._Parameter('B', _float_ptr_type,'in', _matrix_2_ambn_bm_even2) - _param_C = validate_env._Parameter('C', _float_ptr_type,'out',_matrix_2_an_bm_lambda_ij_0) - _param_ambn = validate_env._Parameter('ambn',_int_type, 'in', _add_an_bm) - _param_an = validate_env._Parameter('an', _int_type, 'in', _const_2) - _param_bm = validate_env._Parameter('bm', _int_type, 'in', _const_3) - self._Parameter_order_by_freevars_test_data = [ - ([_param_A, _param_B, _param_C, _param_ambn, _param_an, _param_bm], ['an','bm','C','ambn','A','B']) - ] - _float_3_type = validate_env._CppArrayType(_float_type, [_const_3]) - _float_3_2_type = validate_env._CppArrayType(_float_type, [_const_3,_const_2]) - _name_N = validate_env._NameExpr('N') - _float_N_type = validate_env._CppArrayType(_float_type, [_name_N]) - _float_N_2_type = validate_env._CppArrayType(_float_type, [_name_N,_const_2]) - self._CppType_statictype_test_data = [ - ((_int_type, dict()), 'int'), - ((_float_ptr_type, dict()), 'float*'), - ((_float_3_type, dict()), 'float[3]'), - ((_float_N_type, {'N': 3}), 'float[3]'), - ((_float_N_2_type, {'N': 3}), 'float[3][2]') - ] - _int_ptr_type = validate_env._CppPointerType(_int_type) - _int_ptr_ptr_type = validate_env._CppPointerType(_int_ptr_type) - _int_3_type = validate_env._CppArrayType(_int_type, [_const_3]) - _int_N_type = validate_env._CppArrayType(_int_type, [_name_N]) - _int_3_2_type = validate_env._CppArrayType(_int_type, [_const_3, _const_2]) - joinbytes = lambda b: functools.reduce(lambda a,v: a+v,b) - self._CppType_formatdata_test_data = [ - ((_int_type, dict(), 3), ([1], struct.pack('i',3))), - ((_float_type, dict(), float(3)), ([1], struct.pack('f',float(3)))), - ((_int_3_type, dict(), list(range(3))), ([3], joinbytes([struct.pack('i',i) for i in range(3)]))), - ((_int_3_2_type, dict(), list(range(6))), ([3,2], joinbytes([struct.pack('i',i) for i in range(6)]))), - ((_int_ptr_type, dict(), 3), ([1,1], struct.pack('i',3))), - ((_int_ptr_type, dict(), list(range(3))), ([3,1], joinbytes([struct.pack('i',i) for i in range(3)]))), - ((_int_ptr_ptr_type, dict(), list(range(3))), ([3,1,1], joinbytes([struct.pack('i',i) for i in range(3)]))), - ((_int_ptr_ptr_type, dict(), [[0,1,2],[3,4,5]]), ([2,3,1], joinbytes([struct.pack('i',i) for i in range(6)]))), - ] - evendist2 = lambda i,j: random.random() - random.seed(0) - self._Parameter_generatedata_test_state = random.getstate() - if testchill.util.python_version_major == 2: - self._Parameter_generatedata_test_data = [ - ((_param_A, {'an':2, 'ambn':5,'evendist2':evendist2}), ('A', 'float*', [10, 1], '\x08,X?M\tB?)U\xd7>\xbc\x90\x84>\xe6\xe2\x02?\x87S\xcf>\x06\xa7H?\xceK\x9b>\x84\x04\xf4>\x86X\x15?')), - ((_param_B, {'ambn':5, 'bm':3,'evendist2':evendist2}), ('B', 'float*', [15, 1], '\x16zh?(3\x01?\rM\x90>b|A?nM\x1e?^B\x80>!\xe5h?\xd4\x97{?fjO?Y\xf4f?\xaa\xcb\x9e>A\xd6:?D\x1af?\x92\x19/?\xb1\xbc\xf1>')), - ((_param_C, {'an':2, 'bm':3, 'evendist2':evendist2}), ('C', 'float*', [6, 1], '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')), - ((_param_ambn, {'an':2, 'bm':3}), ('ambn', 'int', [1], '\x05\x00\x00\x00')), - ((_param_an, dict()), ('an', 'int', [1], '\x02\x00\x00\x00')), - ((_param_bm, dict()), ('bm', 'int', [1], '\x03\x00\x00\x00')) - ] - else: - self._Parameter_generatedata_test_data = [ - ((_param_A, {'an':2, 'ambn':5,'evendist2':evendist2}), ('A', 'float*', [10, 1], b'\x08,X?M\tB?)U\xd7>\xbc\x90\x84>\xe6\xe2\x02?\x87S\xcf>\x06\xa7H?\xceK\x9b>\x84\x04\xf4>\x86X\x15?')), - ((_param_B, {'ambn':5, 'bm':3,'evendist2':evendist2}), ('B', 'float*', [15, 1], b'\x16zh?(3\x01?\rM\x90>b|A?nM\x1e?^B\x80>!\xe5h?\xd4\x97{?fjO?Y\xf4f?\xaa\xcb\x9e>A\xd6:?D\x1af?\x92\x19/?\xb1\xbc\xf1>')), - ((_param_C, {'an':2, 'bm':3, 'evendist2':evendist2}), ('C', 'float*', [6, 1], b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')), - ((_param_ambn, {'an':2, 'bm':3}), ('ambn', 'int', [1], b'\x05\x00\x00\x00')), - ((_param_an, dict()), ('an', 'int', [1], b'\x02\x00\x00\x00')), - ((_param_bm, dict()), ('bm', 'int', [1], b'\x03\x00\x00\x00')) - ] - ### data for parsing ### - self.parse_procedure_test_data = [ - (('procedure void q()',), ('void', 'q', 0)), - (('procedure int q()',), ('int', 'q', 0)), - (('procedure float q()',), ('float', 'q', 0)), - (('procedure unsigned int q()',), ('unsigned int', 'q', 0)), - (('procedure void q(in int x)',), ('void', 'q', 1)), - (('procedure void q(in int x, in int y)',), ('void', 'q', 2)), - ] - _mm_proc_expr = ''' - procedure void mm( - in float* A = matrix([an,ambn],evendist2), - in float* B = matrix([ambn,bm],evendist2), - out float* C = matrix([an,bm],lambda i,j: 0), - in int ambn = an + bm, - in int an = 2, - in int bm = 3) - ''' - self.parse_parameter_test_data = [ - (('procedure void mm(in int x)',), [(0, 'x', 'int', 'in', False, set())]), - (('procedure void mm(out int* x = 10)',), [(0, 'x', 'int*', 'out', True, set())]), - ((_mm_proc_expr,),[ - (0, 'A', 'float*', 'in', True, set(['an','ambn','evendist2'])), - (1, 'B', 'float*', 'in', True, set(['ambn','bm','evendist2'])), - (2, 'C', 'float*', 'out', True, set(['an','bm'])), - (3, 'ambn', 'int', 'in', True, set(['an','bm'])), - (4, 'an', 'int', 'in', True, set([])), - (5, 'bm', 'int', 'in', True, set([])) - ]), - ] - ### data for code generation ### - _float_2d_type = validate_env._CppArrayType(_float_type, [_name_an,_name_ambn]) - self._CppType_statictype_test_data = [ - ((_float_2d_type, {'an':2,'ambn':5}), 'float[2][5]') - ] - self._CppType_get_cdecl_stmt_test_data = [ - ((_float_2d_type, 'A', {'an':2,'ambn':5}), 'float A[2][5];') - ] - self._CppType_get_cread_stmt_test_data = [ - ((_float_2d_type, 'A', {'an':2,'ambn':5}, 'datafile_initialize', [10,1]), 'datafile_initialize.read((char*)A, 10*sizeof(float));') - ] - self._CppType_get_cwrite_stmt_test_data = [ - ((_float_2d_type, 'A', {'an':2,'ambn':5}, 'datafile_out', [10,1]), 'datafile_out.write((char*)A, 10*sizeof(float));') - ] - - def run_expr_test_data(self, ctor, test_data): - for ctor_args, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value in test_data: - expr = ctor(*ctor_args) - _expr_test(self, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value) - - def run_expr_test_data_list(self, ctor, test_data): - for ctor_args, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value in test_data: - expr = ctor(*ctor_args) - _expr_test_list(self, expr, fv_bindings, rt_bindings, target_type, exp_freevars, exp_value) - - def run_expr_test_data_invoke(self, ctor, test_data): - for ctor_args, fv_bindings, rt_bindings, target_type, exp_freevars, invoke_args, exp_value in test_data: - expr = ctor(*ctor_args) - _expr_test_invoke(self, expr, fv_bindings, rt_bindings, target_type, exp_freevars, invoke_args, exp_value) - - def test__ConstantExpr(self): - self.run_expr_test_data(validate_env._ConstantExpr, self._ConstantExpr_test_data) - - def test__NameExpr(self): - self.run_expr_test_data(validate_env._NameExpr, self._NameExpr_test_data) - - def test__AttributeExpr(self): - self.run_expr_test_data(validate_env._AttributeExpr, self._AttributeExpr_test_data) - - def test__UnaryExpr(self): - self.run_expr_test_data(validate_env._UnaryExpr, self._UnaryExpr_test_data) - - def test__LambdaExpr(self): - self.run_expr_test_data_invoke(validate_env._LambdaExpr, self._LambdaExpr_test_data) - - def test__InvokeExpr(self): - self.run_expr_test_data(validate_env._InvokeExpr, self._InvokeExpr_test_data) - - def test__MatrixGenerator(self): - self.run_expr_test_data_list(validate_env._MatrixGenerator, self._MatrixGenerator_test_data) - - def test__RandomExpr(self): - random.setstate(self._RandomExpr_test_state) - self.run_expr_test_data(validate_env._RandomExpr, self._RandomExpr_test_data) - - def test_parse_procedure(self): - parse_func = testchill.cpp_validate._parse_testproc_script - for args, expected in self.parse_procedure_test_data: - rtype_exp, name_exp, param_count_exp = expected - proc = parse_func(*args) - self.assertEqual(str(proc.rtype), rtype_exp) - self.assertEqual(proc.name, name_exp) - self.assertEqual(len(proc.parameters), param_count_exp) - - def test_parse_parameter(self): - #pylang.debug.enable(['pylang.parser.BaseTextParser.parse']) - parse_func = testchill.cpp_validate._parse_testproc_script - for args, expected in self.parse_parameter_test_data: - proc = parse_func(*args) - for param_exp in expected: - index, name_exp, ctype_exp, direction_exp, has_init_exp, freevars_exp = param_exp - param = proc.parameters[index] - self.assertEqual(param.name, name_exp) - self.assertEqual(str(param.cpptype), ctype_exp) - self.assertEqual(param.direction, direction_exp) - self.assertEqual(param.init_expr is not None, has_init_exp) - self.assertEqual(param.getfreevars(), freevars_exp) - #pylang.debug.enable(['pylang.parser.BaseTextParser.parse'], False) - - def test__Parameter_order_by_freevars(self): - def testfunc(param_list): - return [p.name for p in validate_env._Parameter.order_by_freevars(param_list)] - for arg, expected in self._Parameter_order_by_freevars_test_data: - self.assertEqual(testfunc(arg),expected) - - def test__CppType_statictype(self): - def testfunc(ctype, glbls): - return str(ctype.statictype(glbls)) - for args, expected in self._CppType_statictype_test_data: - self.assertEqual(testfunc(*args), expected) - - def test__CppType_formatdata(self): - def testfunc(ctype, glbls, data): - return ctype.statictype(glbls).formatdata(data) - for args, expected in self._CppType_formatdata_test_data: - dim_exp, bytes_exp = expected - dim_val, bytes_val = testfunc(*args) - self.assertEqual(dim_val, dim_exp) - self.assertEqual(bytes_val, bytes_exp) - - def test__CppType_statictype(self): - def testfunc(t, bindings): - return str(t.statictype(bindings)) - for args, typename in self._CppType_statictype_test_data: - self.assertEqual(testfunc(*args), typename) - - def test__CppType_get_cdecl_stmt(self): - def testfunc(t, param_name, bindings): - return t.statictype(bindings).get_cdecl_stmt(param_name) - for args, decl_exp in self._CppType_get_cdecl_stmt_test_data: - decl_val = testfunc(*args) - self.assertEqual(decl_val, decl_exp) - - def test__CppType_get_cread_stmt(self): - def testfunc(t, param_name, bindings, stream, dims): - return t.statictype(bindings).get_cread_stmt(param_name, stream, dims) - for args, decl_exp in self._CppType_get_cread_stmt_test_data: - decl_val = testfunc(*args) - self.assertEqual(decl_val, decl_exp) - - def test__CppType_get_cwrite_stmt(self): - def testfunc(t, param_name, bindings, stream, dims): - return t.statictype(bindings).get_cwrite_stmt(param_name, stream, dims) - for args, decl_exp in self._CppType_get_cwrite_stmt_test_data: - decl_val = testfunc(*args) - self.assertEqual(decl_val, decl_exp) - - def test__Parameter_generatedata(self): - def testfunc(param, glbls): - return param.generatedata(glbls) - for args, expected in self._Parameter_generatedata_test_data: - name_val, type_val, dims_val, data_val = testfunc(*args) - name_exp, type_exp, dims_exp, data_exp = expected - #print((name_val,type_val,dims_val,data_val)) - self.assertEqual(name_val, name_exp) - self.assertEqual(str(type_val), type_exp) - self.assertEqual(dims_val, dims_exp) - self.assertEqual(data_val, data_exp) - -- cgit v1.2.3-70-g09d2