def test_class_method_simple(self): """ Make sure the function works on class instance methods. """ from io import StringIO dummy = StringIO() class TestClass(): # noinspection PyMethodMayBeStatic def testfunc(self, arg): foo = float(arg) bar = str(foo) baz = len(bar) print(baz, file=dummy) return baz def __len__(self): return 1 t = TestClass() expected = t.testfunc result = _make_constant_globals(expected, self.test_env) expected_consts = (None, 'file', float, str, len, print) self.check_co_consts(result, expected_consts) # make sure it works call_result = t.testfunc(12) exp = 4 self.assertEqual(call_result, exp) self.assertEqual(str(call_result) + '\n', dummy.getvalue())
def time_testfoo2(): from timeit import Timer from pysrc.optimize.optimize_constants import _make_constant_globals import builtins env = vars(builtins).copy() env.update(globals()) before = Timer(testfoo2).timeit after = Timer(_make_constant_globals(testfoo2, env)).timeit before_total = after_total = 0 from itertools import count n = 3 for i in count(1): bresult = before(n) aresult = after(n) before_total += bresult after_total += aresult print() print("Before:", bresult, "After:", aresult) print("Before Total", before_total / i, "After Total:", after_total / i) print()
def test_simple_buitins2(self): def testfunc2(dummy): dummy_len = len(dummy) print(dummy_len) expected = (None, len, print) result_func = _make_constant_globals(testfunc2, self.test_env) self.assertIsNotNone(result_func, "Forgot to return function!") self.assertIsNot(result_func, testfunc2, "Function not modified") self.check_co_consts(result_func, expected, 'testfunc2')
def test_make_constants_smooth1(self): """ import the unittest for smooth1. Run them once to verify passing, then modify the module namespace with modified function, and run again. This is probably not the best way to do this, but oh well. @return: None @rtype: None """ from pysrc.test.test_smooth import test_smooth ref_smooth = test_smooth.smooth1 new_smooth = _make_constant_globals(ref_smooth, self.test_env) if new_smooth is ref_smooth: raise self.failureException("Function not modified- unexpected failure") test_case = test_smooth.Smooth() tests = ( test_case.test_smooth1_1, test_case.test_smooth1_2, test_case.test_smooth1_real1 ) # Catch and re-raise each exception on failure for # accurate error reporting # first pass- assert all the other tests actually pass. # even though its not our fault, silently ignoring errors # could result in false positives. for test in tests: try: test() except self.failureException: raise self.failureException("Unrelated test unexpectedly failed") from None except: raise self.failureException("Unknown error from unrelated test") from None # Second pass- modify and see if they still pass for test in tests: test_smooth.smooth1 = new_smooth try: test() except self.failureException: # restore ref_smooth in case future tests added to run test_smooth.smooth1 = ref_smooth raise self.failureException("Mismatch result after modification in test %s" % test.__name__)
def test_simple_store_global(self): """ Test a function with STORE_GLOBAL opcodes """ def test_globals(): global foo print(foo) foo = 1 expected = test_globals result = _make_constant_globals(expected, self.test_env) self.assertIs(expected, result, "Function incorrectly modified")
def test_simple_builtins1(self): """ @return: None @rtype: None """ def testfunc1(dummy): print(len(dummy)) expected = (None, print, len) result_func = _make_constant_globals(testfunc1, self.test_env) self.assertIsNotNone(result_func, "Forgot to return function!") self.assertIsNot(result_func, testfunc1, "Function not modified") self.check_co_consts(result_func, expected, "testfunc1")
def test_kw_defaults(self): """ There was some bug I found where running a function with kw-only defaults (scripts.old_cli.plot) through the make_constants function resulted in a "keyword only arg requires argument" error upon calling the function without explicitly specifying the error. """ src = """ def func(*, kwarg="hello world"): print(kwarg) """ ns = {} exec(src, ns, ns) func = ns['func'] func() after = _make_constant_globals(func, {'print' : print}) after()