def calc_error_helper(self, message, expected_result): from UnitTesting.calc_error import calc_error if version_info[0] == 2 or version_info[1] < 4: from testfixtures import LogCapture tuple_list = [] for string in message: string_tuple = string.split(':', 2) string_tuple[0], string_tuple[1] = string_tuple[1], string_tuple[0] tuple_list.append(tuple(string_tuple)) tuple_tuple = tuple(tuple_list) with LogCapture() as logger: self.assertTrue(expected_result == calc_error(self)) logger.check(*tuple_tuple) else: with self.assertLogs(level='DEBUG') as logger: self.assertEqual(expected_result, calc_error(self)) self.assertEqual(logger.output, message)
def test_calc_error(self): from UnitTesting.calc_error import calc_error from datetime import date mp.dps = precision self.module_name = 'TestModule' self.trusted_values_dict_name = 'TestModule__globals' self.calculated_dict = {} self.trusted_values_dict_entry = {} self.assertEqual(True, calc_error(self)) self.calculated_dict = {'a': mpf('1.0')} self.trusted_values_dict_entry = {} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['a']" ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('1.0'), 'b': mpf('2.0')} self.trusted_values_dict_entry = {} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['a', 'b']" ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('1.0')} self.trusted_values_dict_entry = {'b': mpf('2.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['a']", 'ERROR:root: Trusted Dictionary variables not in Calculated Dictionary: ' + "['b']" ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('2.0'), 'b': mpf('3.0')} self.trusted_values_dict_entry = {'c': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['a', 'b']", 'ERROR:root: Trusted Dictionary variables not in Calculated Dictionary: ' + "['c']" ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('2.0'), 'b': mpf('3.0')} self.trusted_values_dict_entry = {'a': mpf('1.0'), 'c': mpf('4.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['b']", 'ERROR:root: Trusted Dictionary variables not in Calculated Dictionary: ' + "['c']" ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('1.0'), 'b': mpf('2.0')} self.trusted_values_dict_entry = {'c': mpf('3.0'), 'd': mpf('4.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['a', 'b']", 'ERROR:root: Trusted Dictionary variables not in Calculated Dictionary: ' + "['c', 'd']" ] calc_error_helper(self, message, False) self.calculated_dict = {'b': mpf('1.0'), 'a': mpf('2.0')} self.trusted_values_dict_entry = {'c': mpf('3.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'ERROR:root: TestModule: Calculated dictionary and trusted dictionary have different variables.', 'ERROR:root: Calculated Dictionary variables not in Trusted Dictionary: ' + "['a', 'b']", 'ERROR:root: Trusted Dictionary variables not in Calculated Dictionary: ' + "['c']" ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('1.0')} self.trusted_values_dict_entry = {'a': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '1.0' + '\n', 'DEBUG:root: ...Success: all variables identical.\n' ] calc_error_helper(self, message, True) self.calculated_dict = {'a': mpf('1.0'), 'b': mpf('2.0')} self.trusted_values_dict_entry = {'a': mpf('1.0'), 'b': mpf('2.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '1.0' + '\n', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '2.0' + '\nTestModule: ' + 'b' + ': Trusted: ' + '2.0' + '\n', 'DEBUG:root: ...Success: all variables identical.\n' ] calc_error_helper(self, message, True) self.calculated_dict = {'a': mpf('1.0'), 'b': mpf('2.0')} self.trusted_values_dict_entry = {'b': mpf('2.0'), 'a': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '1.0' + '\n', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '2.0' + '\nTestModule: ' + 'b' + ': Trusted: ' + '2.0' + '\n', 'DEBUG:root: ...Success: all variables identical.\n' ] calc_error_helper(self, message, True) self.calculated_dict = {'b': mpf('2.0'), 'a': mpf('1.0')} self.trusted_values_dict_entry = {'b': mpf('2.0'), 'a': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '1.0' + '\n', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '2.0' + '\nTestModule: ' + 'b' + ': Trusted: ' + '2.0' + '\n', 'DEBUG:root: ...Success: all variables identical.\n' ] calc_error_helper(self, message, True) self.calculated_dict = {'a': mpf('1.0')} self.trusted_values_dict_entry = {'a': mpf('2.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '2.0' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['a']", str(date.today()), "{'a': mpf('1.0')}") ] calc_error_helper(self, message, False) ## Broken test: FAILS WITH precision > 30 # self.calculated_dict = {'a': mpf('1.0')} # self.trusted_values_dict_entry = {'a': mpf('1.00000000000000010000000000000')} # message = ['DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', # 'DEBUG:root: ...Success: same variables in both dicts.\n', # 'DEBUG:root: Comparing all calculated and trusted values...', # 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '1.0000000000000001' + '\n', # 'DEBUG:root: ...Success: all variables identical.\n' # ] # calc_error_helper(self, message, True) ## Broken test: FAILS WITH precision > 30 # self.calculated_dict = {'a': mpf('0.0')} # self.trusted_values_dict_entry = {'a': mpf('0.0000000000000001')} # message = ['DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', # 'DEBUG:root: ...Success: same variables in both dicts.\n', # 'DEBUG:root: Comparing all calculated and trusted values...', # 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '0.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '1.0e-16' + '\n', # 'DEBUG:root: ...Success: all variables identical.\n' # ] # calc_error_helper(self, message, True) self.calculated_dict = {'b': mpf('0.0')} self.trusted_values_dict_entry = {'b': mpf('0.000000000000001')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '0.0' + '\nTestModule: ' + 'b' + ': Trusted: ' + '1.0e-15' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['b']", str(date.today()), "{'b': mpf('0.0')}") ] calc_error_helper(self, message, False) ## Broken test: FAILS WITH precision > 30 # self.calculated_dict = {'a': mpf('0.0000000000000001')} # self.trusted_values_dict_entry = {'a': mpf('0.0')} # message = ['DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', # 'DEBUG:root: ...Success: same variables in both dicts.\n', # 'DEBUG:root: Comparing all calculated and trusted values...', # 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '1.0e-16' + '\nTestModule: ' + 'a' + ': Trusted: ' + '0.0' + '\n', # 'DEBUG:root: ...Success: all variables identical.\n' # ] # calc_error_helper(self, message, True) self.calculated_dict = {'alpha': mpf('0.000000000000001')} self.trusted_values_dict_entry = {'alpha': mpf('0.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'alpha' + ': Calculated: ' + '1.0e-15' + '\nTestModule: ' + 'alpha' + ': Trusted: ' + '0.0' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['alpha']", str(date.today()), "{'alpha': mpf('1.0e-15')}") ] calc_error_helper(self, message, False) self.calculated_dict = {'f': mpf('123.012345678901234567890123456')} self.trusted_values_dict_entry = { 'f': mpf('123.012345678901234567890123456') } message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'f' + ': Calculated: ' + '123.012345678901234567890123456' + '\nTestModule: ' + 'f' + ': Trusted: ' + '123.012345678901234567890123456' + '\n', 'DEBUG:root: ...Success: all variables identical.\n' ] calc_error_helper(self, message, True) self.calculated_dict = {'f': mpf('123.0123456781012345678901')} self.trusted_values_dict_entry = { 'f': mpf('123.0123456789012345678901') } message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'f' + ': Calculated: ' + '123.0123456781012345678901' + '\nTestModule: ' + 'f' + ': Trusted: ' + '123.0123456789012345678901' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['f']", str(date.today()), "{'f': mpf('123.0123456781012345678901')}") ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('0.0'), 'b': mpf('1.0')} self.trusted_values_dict_entry = {'a': mpf('0.1'), 'b': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '0.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '0.1' + '\n', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '1.0' + '\nTestModule: ' + 'b' + ': Trusted: ' + '1.0' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['a']", str(date.today()), "{'a': mpf('0.0'), 'b': mpf('1.0')}") ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('0.0'), 'b': mpf('1.1')} self.trusted_values_dict_entry = {'a': mpf('0.1'), 'b': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '0.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '0.1' + '\n', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '1.1' + '\nTestModule: ' + 'b' + ': Trusted: ' + '1.0' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['a', 'b']", str(date.today()), "{'a': mpf('0.0'), 'b': mpf('1.1')}") ] calc_error_helper(self, message, False) self.calculated_dict = {'a': mpf('0.0'), 'b': mpf('1.1')} self.trusted_values_dict_entry = {'a': mpf('0.0'), 'b': mpf('1.0')} message = [ 'DEBUG:root: Checking that calculated and trusted dicts contain the same variables...', 'DEBUG:root: ...Success: same variables in both dicts.\n', 'DEBUG:root: Comparing all calculated and trusted values...', 'DEBUG:root:' + '\nTestModule: ' + 'a' + ': Calculated: ' + '0.0' + '\nTestModule: ' + 'a' + ': Trusted: ' + '0.0' + '\n', 'DEBUG:root:' + '\nTestModule: ' + 'b' + ': Calculated: ' + '1.1' + '\nTestModule: ' + 'b' + ': Trusted: ' + '1.0' + '\n', 'ERROR:root:' + ''' \nVariable(s) {} in module TestModule failed. Please check values. If you are confident that the newly calculated values are correct, comment out the old trusted values for TestModule__globals in your trusted_values_dict and copy the following code between the ##### into your trusted_values_dict. Make sure to fill out the TODO comment describing why the values had to be changed. Then re-run test script. ##### # Generated on: {} # Reason for changing values: TODO trusted_values_dict['TestModule__globals'] = {} ##### '''.format("['b']", str(date.today()), "{'a': mpf('0.0'), 'b': mpf('1.1')}") ] calc_error_helper(self, message, False) logging.info(' All calc_error tests passed.')
def run_test(self): # Step 1: Setup logging.info(' Currently working on function ' + self.function + ' in module ' + self.module_name + '...\n') # Step 1.a: Set precision to the value defined in standard_constants mp.dps = precision # Step 1.b: Import trusted_values_dict from trusted_values_dict.py in self.path logging.info(' Importing trusted_values_dict...') self.trusted_values_dict = import_module( 'trusted_values_dict').trusted_values_dict logging.info(' ...Success: Imported trusted_values_dict.\n') # Step 1.c: Set boolean self.first_time based on existence of desired trusted_values_dict entry self.first_time = self.trusted_values_dict_name not in self.trusted_values_dict if self.first_time: logging.info( ' Proper entry not in trusted_values_dict -- ' 'this function in this module is being run for the first time.') # Step 1.e: Set trusted_values_dict_entry to its corresponding trusted_values_dict entry self.trusted_values_dict_entry = {} if self.first_time else self.trusted_values_dict[ self.trusted_values_dict_name] # Step 2: Calculation # Step 2.a: Call evaluate_globals which calls self.function and gets expressions for all globals in self.global_list logging.info(' Calling evaluate_globals...') self.variable_dict = evaluate_globals(self) logging.info(' ...Success: evaluate_globals ran without errors.\n') # Step 2.b: Call cse_simplify_and_evaluate_sympy_expressions to assign each variable in each expression a random # value and calculate the numerical result logging.info(' Calling cse_simplify_and_evaluate_sympy_expressions...') self.calculated_dict = cse_simplify_and_evaluate_sympy_expressions(self) logging.info( ' ...Success: cse_simplify_and_evaluate_sympy_expressions ran without errors.\n' ) # Step 3: Comparison if self.first_time: # Step 3.a: Print self.calculated_dict in a nice format and append it to trusted_values_dict logging.info( ' Calling first_time_print since it is being run for the first time...' ) first_time_print(self) logging.info( ' ...Success: first_time_print ran without errors. Automatically failing due to first_time.\n' ) self.assertTrue(False) else: # Step 3.b: Call calc_error to calculate the error between the trusted values and the calculated values logging.info(' Calling calc_error...') values_identical = calc_error(self) # If there is an error large enough, fail if not values_identical: self.assertTrue( values_identical, 'Variable(s) above have different calculated and trusted values. Follow ' 'instructions above.') # Otherwise, pass else: logging.info(' ...Success: calc_error ran without errors.\n')
def test_globals(self): self.module = 'GiRaFFEfood_HO.GiRaFFEfood_HO' self.module_name = 'GiRaFFEfood_HO' self.function = 'GiRaFFEfood_HO()' self.global_list = ['AD', 'ValenciavU'] self.initialization_string = """""" self.trusted_values_dict_name = 'GiRaFFEfood_HO__GiRaFFEfood_HO__globals' try: # Step 1.a: Initialize core Python/UnitTesting modules from UnitTesting.calc_error import calc_error from UnitTesting.evaluate_globals import evaluate_globals from UnitTesting.first_time_print import first_time_print from UnitTesting.cse_simplify_and_evaluate_sympy_expressions import cse_simplify_and_evaluate_sympy_expressions from UnitTesting.standard_constants import precision from mpmath import mp from importlib import import_module import logging logging.info(' Currently working on function ' + self.function + ' in module ' + self.module_name + '...\n') # Step 1.b: Set precision to the value defined in standard_constants mp.dps = precision # Step 1.c: Import trusted_values_dict from trusted_values_dict.py in self.path logging.info(' Importing trusted_values_dict...') self.trusted_values_dict = import_module('trusted_values_dict').trusted_values_dict logging.info(' ...Success: Imported trusted_values_dict.\n') # Step 1.d: Set boolean self.first_time based on existence of desired trusted_values_dict entry self.first_time = self.trusted_values_dict_name not in self.trusted_values_dict logging.debug(' First time: ' + str(self.first_time)) # Step 1.e: Set trusted_values_dict_entry to its corresponding trusted_values_dict entry self.trusted_values_dict_entry = {} if self.first_time else self.trusted_values_dict[self.trusted_values_dict_name] # Step 2: Calculation # Step 2.a: Call evaluate_globals which calls self.function and gets expressions for all globals in self.global_list logging.info(' Calling evaluate_globals...') self.variable_dict = evaluate_globals(self) logging.info(' ...Success: evaluate_globals ran without errors.\n') # Step 2.b: Call cse_simplify_and_evaluate_sympy_expressions to assign each variable in each expression a random # value and calculate the numerical result logging.info(' Calling cse_simplify_and_evaluate_sympy_expressions...') self.calculated_dict = cse_simplify_and_evaluate_sympy_expressions(self) logging.info(' ...Success: cse_simplify_and_evaluate_sympy_expressions ran without errors.\n') # Step 3: Comparison if self.first_time: # Step 3.a: Print self.calculated_dict in a nice format and append it to trusted_values_dict logging.info(' Calling first_time_print since it is being run for the first time...') first_time_print(self) logging.info(' ...Success: first_time_print ran without errors. Automatically failing due to first_time.\n') self.assertTrue(False) else: # Step 3.b: Call calc_error to calculate the error between the trusted values and the calculated values logging.info(' Calling calc_error...') values_identical = calc_error(self) # If there is an error large enough, fail if not values_identical: self.assertTrue(values_identical, 'Variable(s) above have different calculated and trusted values. Follow ' 'instructions above.') # Otherwise, pass else: logging.info(' ...Success: calc_error ran without errors.\n') # Something failed except AssertionError: pass # Nothing failed else: import os file = open(os.path.join(self.path, 'success.txt'), 'w') file.close()
def run_test(self, mod_dict, trusted_values_dict, path, locs): # Can't use empty dictionaries assert mod_dict != dict() mp.dps = precision # Determining if this is the first time the code is run based of the existence of trusted values first_times = is_first_time(mod_dict, trusted_values_dict) # Creating trusted dictionary based off names of modules in ModDict trusted_dict = create_trusted_globals_dict(mod_dict, trusted_values_dict, first_times) # Timing how long evaluate_globals takes t = time() # Creating dictionary of expressions for all modules in ModDict result_dict = evaluate_globals(mod_dict, locs) # Printing the time it took to run evaluate_globals logging.debug(str(time() - t) + ' seconds to run evaluate_globals') del mod_dict # # If it is the first time for at least one module, sort the module dictionary based on first_times. # # This makes it so the new modules are done last. This makes it easy to copy the necessary modules' code. # if True in first_times: # # https://stackoverflow.com/questions/13668393/python-sorting-two-lists # first_times, result_mods = (list(x) for x in zip(*sorted(zip(first_times, result_dict)))) # # temp_dict = dict() # # # Creates dictionary based on order of first_times # for mod in result_mods: # temp_dict[mod] = result_dict[mod] # # # Updates resultDict to be in this new order # result_dict = temp_dict # del temp_dict, result_mods # Looping through each module in resultDict for mod in result_dict: var_dict = result_dict[mod] first_time = first_times[mod] if not first_time: logging.info('Currently working on module ' + mod + '...') # Generating variable list and name list for module new_dict = expand_variable_dict(var_dict) # Timing how long list_to_value_list takes t = time() # Calculating numerical list for module value_dict = simplify_and_evaluate_sympy_expressions( new_dict, first_time) # Printing the time it took to run list_to_value_list logging.debug(str(time() - t) + ' seconds to run list_to_value_list') # If being run for the first time, print the code that must be copied into trusted_values_dict if first_time: first_time_print(mod, value_dict, path) # Otherwise, compare calculated values to trusted values else: # Calculates the error between mod_dict and trusted_dict[mod] for the current module values_identical = calc_error(mod, value_dict, trusted_dict[mod]) # If at least one value differs, print exit message and fail the unittest if not values_identical: self.assertTrue( values_identical, 'Variable above has different calculated and trusted values. Follow ' 'above instructions.') # If every value is the same, completed module. else: logging.info('Completed module ' + mod + ' with no errors.\n') self.assertTrue(values_identical) # If it's the first time for at least one module if True in first_times.values(): self.assertTrue( False, 'Automatically failing due to first time for at least one module. Please see above ' 'for the code to copy into your trusted_values_dict.')