def execution_monitor(file_path, pragma_dictionary): """ <Purpose> Executes a unit test written with a source contained in file_path. If the source contains any pragmas (#pragma out, #pragma repy, #pragma err), the unit testing framework creates the report differently. If there is a repy pragma, the test executes in repy, not python. If there is an out or err pragma, the unit testing framework will include that there was to be output in the report. <Arguments> file_path: file to be executed under the framework pragma_dictionary: dictionary of pragmas within this test file <Exceptions> None <Side Effects> None <Returns> A report containing information about any unexpected output: { Pragma Type : (Produced, Expected), ... } """ # Status report. report = { } executable = sys.executable popen_args = [ executable ] if pragma_dictionary.has_key(REPY_PRAGMA): repy = 'repy.py' default_restriction = 'restrictions.default' # Did the user specify a non-default restrictions file? repyArgs = pragma_dictionary[REPY_PRAGMA] if not repyArgs: repyArgs = default_restriction popen_args.append(repy) # For tests requiring repy arguments besides restrictions.default # the user must specify them after the pragma arguments = repyArgs.split(" ") for element in arguments: popen_args.append(element) popen_args.append(file_path) # Execute the program. (out, error) = utfutil.execute(popen_args) report = {} verify_results(OUT_PRAGMA, pragma_dictionary, out, report) verify_results(ERROR_PRAGMA, pragma_dictionary, error, report) return report
def execution_monitor(file_path, pragma_dictionary, security_layers): """ <Purpose> Executes a unit test written with a source contained in file_path. If the source contains any pragmas (#pragma out, #pragma repy, #pragma err), the unit testing framework creates the report differently. If there is a repy pragma, the test executes in repy, not python. If there is an out or err pragma, the unit testing framework will include that there was to be output in the report. <Arguments> file_path: file to be executed under the framework. pragma_dictionary: dictionary of pragmas within this test file. security_layers: A list of security layers to use. If no security are selected, this should have a value of None. <Exceptions> None <Side Effects> None <Returns> A report containing information about any unexpected output: { Pragma Type : (Produced, Expected), ... } """ # Status report. report = {} popen_args = [] popen_args.append(sys.executable) if pragma_dictionary.has_key(REPY_PRAGMA): restrictions = 'restrictions.default' otherargs = [] repyArgs = pragma_dictionary[REPY_PRAGMA] # Did the user specify a non-default restrictions file? if repyArgs: arguments = repyArgs.split(" ") # The first argument is the restrictions file restrictions = arguments[0] # The remaining arguments are the program's arguments otherargs = arguments[1:] popen_args.append('repy.py') popen_args.append(restrictions) if security_layers: popen_args.append('encasementlib.r2py') popen_args.extend(security_layers) # Add in dylink for import purposes. # MMM: We cannot unfortunately add in dylink blindly, # otherwise it breaks some tests. We need to re-evaluate # and figure out another way of adding dylink to only specific # tests. # popen_args.append('dylink.r2py') # Do allow other args to Repy (#1373) popen_args.extend(otherargs) popen_args.append(file_path) # Execute the program. (out, error) = utfutil.execute(popen_args) report = {} verify_results(OUT_PRAGMA, pragma_dictionary, out, report) verify_results(ERROR_PRAGMA, pragma_dictionary, error, report) return report
def execution_monitor(file_path, pragma_dictionary): """ <Purpose> Executes a unit test written with a source contained in file_path. If the source contains any pragmas (#pragma out, #pragma repy, #pragma err), the unit testing framework creates the report differently. If there is a repy pragma, the test executes in repy, not python. If there is an out or err pragma, the unit testing framework will include that there was to be output in the report. <Arguments> file_path: file to be executed under the framework pragma_dictionary: dictionary of pragmas within this test file <Exceptions> None <Side Effects> None <Returns> A report containing information about any unexpected output: { Pragma Type : (Produced, Expected), ... } """ # Status report. report = { } executable = 'python' popen_args = [ executable ] if pragma_dictionary.has_key(REPY_PRAGMA): repy = 'repy.py' default_restriction = 'restrictions.default' # Did the user specify a non-default restrictions file? repyArgs = pragma_dictionary[REPY_PRAGMA] if not repyArgs: repyArgs = default_restriction popen_args.append(repy) # For tests requiring repy arguments besides restrictions.default # the user must specify them after the pragma arguments = repyArgs.split(" ") for element in arguments: popen_args.append(element) popen_args.append(file_path) # Execute the program. (out, error) = utfutil.execute(popen_args) # Is this executable suppose to produce any output on standard out? if pragma_dictionary.has_key(OUT_PRAGMA): expected_out = pragma_dictionary[OUT_PRAGMA] if not expected_out and not out: # pragma out report[OUT_PRAGMA] = (None, expected_out) elif not expected_out in out: # pragma out [ARGUMENT] report[OUT_PRAGMA] = (out, expected_out) elif out: # If not, make sure the standard out is empty. report[ERROR_PRAGMA] = (out, None) # Is this executable suppose to produce any output on standard error? if pragma_dictionary.has_key(ERROR_PRAGMA): expected_error = pragma_dictionary[ERROR_PRAGMA] if not expected_error and not error: # pragma error report[ERROR_PRAGMA] = (None, expected_error) elif not expected_error in error: # pragma error [ARGUMENT] report[ERROR_PRAGMA] = (error, expected_error) elif error: # If not, make sure the standard error is empty. report[ERROR_PRAGMA] = (error, None) return report
def execution_monitor(file_path, pragma_dictionary, security_layers): """ <Purpose> Executes a unit test written with a source contained in file_path. If the source contains any pragmas (#pragma out, #pragma repy, #pragma err), the unit testing framework creates the report differently. If there is a repy pragma, the test executes in repy, not python. If there is an out or err pragma, the unit testing framework will include that there was to be output in the report. <Arguments> file_path: file to be executed under the framework. pragma_dictionary: dictionary of pragmas within this test file. security_layers: A list of security layers to use. If no security are selected, this should have a value of None. <Exceptions> None <Side Effects> None <Returns> A report containing information about any unexpected output: { Pragma Type : (Produced, Expected), ... } """ # Status report. report = { } popen_args = [] popen_args.append(sys.executable) if pragma_dictionary.has_key(REPY_PRAGMA): restrictions = 'restrictions.default' otherargs = [] repyArgs = pragma_dictionary[REPY_PRAGMA] # Did the user specify a non-default restrictions file? if repyArgs: arguments = repyArgs.split(" ") # The first argument is the restrictions file restrictions = arguments[0] # The remaining arguments are the program's arguments otherargs = arguments[1:] popen_args.append('repy.py') popen_args.append(restrictions) if security_layers: popen_args.append('encasementlib.r2py') popen_args.extend(security_layers) # Do allow other args to Repy (#1373) popen_args.extend(otherargs) popen_args.append(file_path) # Execute the program. (out, error) = utfutil.execute(popen_args) report = {} verify_results(OUT_PRAGMA, pragma_dictionary, out, report) verify_results(ERROR_PRAGMA, pragma_dictionary, error, report) return report
def execution_monitor(file_path, pragma_dictionary): """ <Purpose> Executes a unit test written with a source contained in file_path. If the source contains any pragmas (#pragma out, #pragma repy, #pragma err), the unit testing framework creates the report differently. If there is a repy pragma, the test executes in repy, not python. If there is an out or err pragma, the unit testing framework will include that there was to be output in the report. <Arguments> file_path: file to be executed under the framework pragma_dictionary: dictionary of pragmas within this test file <Exceptions> None <Side Effects> None <Returns> A report containing information about any unexpected output: { Pragma Type : (Produced, Expected), ... } """ # Status report. report = {} executable = 'python' popen_args = [executable] if pragma_dictionary.has_key(REPY_PRAGMA): repy = 'repy.py' default_restriction = 'restrictions.default' # Did the user specify a non-default restrictions file? repyArgs = pragma_dictionary[REPY_PRAGMA] if not repyArgs: repyArgs = default_restriction popen_args.append(repy) # For tests requiring repy arguments besides restrictions.default # the user must specify them after the pragma arguments = repyArgs.split(" ") for element in arguments: popen_args.append(element) popen_args.append(file_path) # Execute the program. (out, error) = utfutil.execute(popen_args) # Is this executable suppose to produce any output on standard out? if pragma_dictionary.has_key(OUT_PRAGMA): expected_out = pragma_dictionary[OUT_PRAGMA] if not expected_out and not out: # pragma out report[OUT_PRAGMA] = (None, expected_out) elif not expected_out in out: # pragma out [ARGUMENT] report[OUT_PRAGMA] = (out, expected_out) elif out: # If not, make sure the standard out is empty. report[ERROR_PRAGMA] = (out, None) # Is this executable suppose to produce any output on standard error? if pragma_dictionary.has_key(ERROR_PRAGMA): expected_error = pragma_dictionary[ERROR_PRAGMA] if not expected_error and not error: # pragma error report[ERROR_PRAGMA] = (None, expected_error) elif not expected_error in error: # pragma error [ARGUMENT] report[ERROR_PRAGMA] = (error, expected_error) elif error: # If not, make sure the standard error is empty. report[ERROR_PRAGMA] = (error, None) return report