def display_assertion(self, line, level ):
def start( level ):
return start_colour( level )
matches = re.match(
r'(?P<file>[a-zA-Z0-9.@_/\s\-]+)[(](?P<line>[0-9]+)[)]: '
'(?P<message>[a-zA-Z0-9(){}:%.*&_<>/\-+=!," \[\]]+)',
line )
if matches:
path = matches.group( 'file' )
line = matches.group( 'line' )
message = matches.group( 'message')
display = self._toolchain.error_format()
sys.stdout.write( display.format(
start(level) + as_emphasised( path ) + start(level),
as_emphasised( line ) + start(level),
message + colour_reset()
) + "\n"
)
else:
sys.stdout.write(
as_colour( level, line ) + "\n"
)
def failed_assertion(self, line ):
def start_error():
return start_colour( "error" )
matches = re.match(
r'(?P<file>[a-zA-Z0-9._/\s\-]+)[(](?P<line>[0-9]+)[)]: '
'(?P<message>[a-zA-Z0-9(){}:&_<>/\-=!," \[\]]+)',
line )
if matches:
path = matches.group( 'file' )
line = matches.group( 'line' )
message = matches.group( 'message')
error = self._toolchain.error_format()
sys.stdout.write( error.format(
start_error() + as_emphasised( path ) + start_error(),
as_emphasised( line ) + start_error(),
message + colour_reset()
) + "\n"
)
else:
sys.stdout.write(
as_colour( "error", line ) + "\n"
)
def display_assertion(self, line, level ):
def start( level ):
return start_colour( level )
matches = re.match(
r'(?P<file>[a-zA-Z0-9._/\s\-]+)[(](?P<line>[0-9]+)[)]: '
'(?P<message>[a-zA-Z0-9(){}:%.*&_<>/\-+=!," \[\]]+)',
line )
if matches:
path = matches.group( 'file' )
line = matches.group( 'line' )
message = matches.group( 'message')
display = self._toolchain.error_format()
sys.stdout.write( display.format(
start(level) + as_emphasised( path ) + start(level),
as_emphasised( line ) + start(level),
message + colour_reset()
) + "\n"
)
else:
sys.stdout.write(
as_colour( level, line ) + "\n"
)
def enter_test(self, test, expected='passed'):
sys.stdout.write(as_emphasised("\nTest [%s]..." % test) + '\n')
self._tests.append({})
test_case = self._tests[-1]
test_case['name'] = test
test_case['expected'] = expected
test_case['suite'] = self._name
test_case['timer'] = cuppa.timer.Timer()
def __init__(self, name, scons_env):
self._name = name
self._scons_env = scons_env
self._timer = None
sys.stdout.write('\n')
sys.stdout.write(as_emphasised("Running Process [{}]".format(name)))
sys.stdout.write('\n')
self._cpu_times = cuppa.timer.CpuTimes(0, 0, 0, 0)
def enter_test( self, test, expected='passed' ) :
sys.stdout.write(
as_emphasised( "\nTest [%s]..." % test ) + '\n'
)
self._tests.append( {} )
test_case = self._tests[-1]
test_case['name'] = test
test_case['expected'] = expected
test_case['suite'] = self._name
test_case['timer'] = cuppa.timer.Timer()
def __init__( self, fmt=None ):
if not fmt:
preamble = self.preamble_from_level()
fmt = self.fmt_with_preamble( preamble )
self._warn_fmt = self.fmt_with_preamble( as_warning_label( preamble ) )
self._error_fmt = self.fmt_with_preamble( as_error_label( preamble ) )
self._critical_fmt = self.fmt_with_preamble( as_error_label( as_emphasised( preamble ) ) )
logging.Formatter.__init__( self, fmt )
def __init__(self, fmt=None):
if not fmt:
preamble = self.preamble_from_level()
fmt = self.fmt_with_preamble(preamble)
self._warn_fmt = self.fmt_with_preamble(as_warning_label(preamble))
self._error_fmt = self.fmt_with_preamble(as_error_label(preamble))
self._critical_fmt = self.fmt_with_preamble(
as_error_label(as_emphasised(preamble)))
logging.Formatter.__init__(self, fmt)
def _command_line_from_settings(self, settings):
commands = []
for key, value in six.iteritems(settings):
command = as_emphasised("--" + key)
if value != True and value != False:
if not isinstance(value, list):
command += "=" + as_info(str(value))
else:
command += "=" + as_info(",".join(value))
commands.append(command)
commands.sort()
return " ".join(commands)
def _command_line_from_settings( self, settings ):
commands = []
for key, value in settings.iteritems():
command = as_emphasised( "--" + key )
if value != True and value != False:
if not isinstance( value, list ):
command += "=" + as_info( str(value) )
else:
command += "=" + as_info( ",".join( value ) )
commands.append( command )
commands.sort()
return " ".join( commands )
def check_current_version():
installed_version = get_version()
logger.info("cuppa: version {}".format(as_info(installed_version)))
try:
pypi = xmlrpclib.ServerProxy('http://pypi.python.org/pypi')
latest_available = pypi.package_releases('cuppa')[0]
if parse_version(installed_version) < parse_version(latest_available):
logger.warn(
"Newer version [{}] available. Upgrade using \"{}\"\n".format(
as_warning(latest_available),
as_emphasised("pip install -U cuppa")))
except:
pass
def check_current_version( offline ):
installed_version = get_version()
logger.info( "cuppa: version {}".format( as_info( installed_version ) ) )
if not offline:
try:
pypi = xmlrpclib.ServerProxy('http://pypi.python.org/pypi')
latest_available = pypi.package_releases('cuppa')[0]
if parse_version( installed_version ) < parse_version( latest_available ):
logger.warn( "Newer version [{}] available. Upgrade using \"{}\"\n".format(
as_warning( latest_available ),
as_emphasised( "pip install -U cuppa" )
) )
except:
pass
def __call__(self, line):
(matches, interpretor, error_id, warning_id) = self.interpret(line)
if matches:
highlights = interpretor['highlight']
display = interpretor['display']
meaning = interpretor['meaning']
file = interpretor['file']
message = ''
for match in display:
element = matches.group(match)
if match == file and (meaning == 'error'
or meaning == 'warning'):
element = self.normalise_path(element)
element = as_colour(meaning, element)
if match in highlights:
element = as_emphasised(element)
message += element
message = self.filtered_line(message + "\n", meaning)
if meaning == 'error':
if message:
message = as_highlighted(
meaning,
" = Error " + str(error_id) + " = ") + "\n" + message
else:
self.errors -= 1
elif meaning == 'warning':
if message:
message = as_highlighted(
meaning, " = Warning " + str(warning_id) +
" = ") + "\n" + message
else:
self.warnings -= 1
return message
return self.filtered_line(line)
def __call__( self, line ):
( matches, interpretor, error_id, warning_id ) = self.interpret( line )
if matches:
highlights = interpretor['highlight']
display = interpretor['display']
meaning = interpretor['meaning']
file = interpretor['file']
message = ''
for match in display:
element = matches.group( match )
if match == file and ( meaning == 'error' or meaning == 'warning' ):
element = self.normalise_path( element )
element = as_colour( meaning, element )
if match in highlights:
element = as_emphasised( element )
message += element
message = self.filtered_line( message + "\n", meaning )
if meaning == 'error':
if message:
message = as_highlighted( meaning, " = Error " + str(error_id) + " = ") + "\n" + message
else:
self.errors -= 1
elif meaning == 'warning':
if message:
message = as_highlighted( meaning, " = Warning " + str(warning_id) + " = ") + "\n" + message
else:
self.warnings -= 1
return message
return self.filtered_line( line )
def __init__( self, name, scons_env ):
self._name = name
self._scons_env = scons_env
sys.stdout.write('\n')
sys.stdout.write(
as_emphasised( "Starting Test Suite [{}]".format( name ) )
)
sys.stdout.write('\n')
self._suite = {}
self._suite['total_tests'] = 0
self._suite['passed_tests'] = 0
self._suite['failed_tests'] = 0
self._suite['expected_failures'] = 0
self._suite['skipped_tests'] = 0
self._suite['aborted_tests'] = 0
self._suite['total_cpu_times'] = cuppa.timer.CpuTimes( 0, 0, 0, 0 )
self._tests = []
cuppa.progress.NotifyProgress.register_callback( scons_env, self.on_progress )
def __init__(self, name, scons_env):
self._name = name
self._scons_env = scons_env
sys.stdout.write('\n')
sys.stdout.write(as_emphasised(
"Starting Test Suite [{}]".format(name)))
sys.stdout.write('\n')
self._suite = {}
self._suite['total_tests'] = 0
self._suite['passed_tests'] = 0
self._suite['failed_tests'] = 0
self._suite['expected_failures'] = 0
self._suite['skipped_tests'] = 0
self._suite['aborted_tests'] = 0
self._suite['total_cpu_times'] = cuppa.timer.CpuTimes(0, 0, 0, 0)
self._tests = []
cuppa.progress.NotifyProgress.register_callback(
scons_env, self.on_progress)
def write( text ):
if not emphasise:
sys.stdout.write( text )
else:
sys.stdout.write( as_emphasised( text ) )
def exit_suite(self, suite):
sys.stdout.write(
as_emphasised( "\nTest Suite Finished [%s] " % suite['name'] )
)
passed_tests = suite['passed_tests']
failed_tests = suite['failed_tests']
expected_failures = suite['expected_failures']
skipped_tests = suite['skipped_tests']
aborted_tests = suite['aborted_tests']
total_assertions = suite['total_assertions']
passed_assertions = suite['passed_assertions']
warned_assertions = suite['warned_assertions']
failed_assertions = suite['failed_assertions']
label = suite['status'].upper()
meaning = suite['status']
if meaning == 'passed' and warned_assertions:
meaning = 'warning'
sys.stdout.write(
as_highlighted( meaning, " = {} = ".format( suite['status'].upper() ) )
)
sys.stdout.write('\n')
sys.stdout.write(
as_emphasised( "\nSummary\n" )
)
for test in suite['tests']:
sys.stdout.write(
as_emphasised( "\nTest case [{}]".format( test['name'] ) ) + '\n'
)
self._write_test_case( test )
sys.stdout.write('\n')
sys.stdout.write(
as_highlighted( meaning, " = %s = " % label )
)
cuppa.timer.write_time( suite['total_cpu_times'] )
if total_assertions > 0:
if suite['status'] == 'passed':
if not warned_assertions:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Assertions Passed )" % (passed_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s Passed + %s Warned out of %s Assertions Passed )" % (passed_assertions, warned_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Assertions Failed )" % (failed_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_colour(
'notice',
" ( No Assertions Checked )"
)
)
if suite['status'] == 'passed' and passed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Passed ) "
% (passed_tests, passed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
elif suite['status'] != 'passed':
self.master_suite['status'] = 'failed'
if failed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Failed ) "
% (failed_tests, failed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if expected_failures > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Expected ) "
% (expected_failures, expected_failures > 1 and 'Failures' or 'Failure')
)
)
if len( skipped_tests ):
number = len( skipped_tests )
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Skipped ) "
% (number, number > 1 and 'Test Cases' or 'Test Case')
)
)
if aborted_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Aborted ) "
% (aborted_tests, aborted_tests > 1 and 'Test Cases Were' or 'Test Case Was')
)
)
sys.stdout.write( '\n\n')
def enter_suite(self, suite):
sys.stdout.write(
as_emphasised( "\nStarting Test Suite [%s]\n" % suite )
)
def enter_test_case(self, test_case):
sys.stdout.write(
as_emphasised( "\nRunning Test Case [%s] ...\n" % test_case['key'] )
)
test_case['timer'] = cuppa.timer.Timer()
def exit_suite(self, suite):
sys.stdout.write(
as_emphasised( "\nTest Suite Finished [%s] " % suite['name'] )
)
label = suite['status'].upper()
meaning = suite['status']
store_durations( suite )
sys.stdout.write(
as_highlighted( meaning, " = %s = " % label )
)
self.__write_time( suite )
total_tests = int(suite['total_tests'])
passed_tests = int(suite['passed_tests'])
failed_tests = int(suite['failed_tests'])
expected_failures = int(suite['expected_failures'])
skipped_tests = int(suite['skipped_tests'])
aborted_tests = int(suite['aborted_tests'])
total_assertions = int(suite['total_assertions'])
passed_assertions = int(suite['passed_assertions'])
failed_assertions = int(suite['failed_assertions'])
if total_assertions > 0:
if suite['status'] == 'passed':
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Assertions Passed )" % (passed_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Assertions Failed )" % (failed_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_colour(
'notice',
" ( No Assertions Checked )"
)
)
if suite['status'] == 'passed' and passed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Passed ) "
% (passed_tests, passed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
elif suite['status'] != 'passed':
self.master_suite['status'] = 'failed'
if failed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Failed ) "
% (failed_tests, failed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if expected_failures > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Expected ) "
% (expected_failures, expected_failures > 1 and 'Failures' or 'Failure')
)
)
if skipped_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Skipped ) "
% (skipped_tests, skipped_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if aborted_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Aborted ) "
% (aborted_tests, aborted_tests > 1 and 'Test Cases Were' or 'Test Case Was')
)
)
sys.stdout.write('\n\n')
def summary(self, returncode):
summary = self._toolchain_processor.summary(returncode)
if returncode and not self._verbose_build:
summary += "\nTry running with {} for more details".format(
as_emphasised('--boost-verbose-build'))
return summary
def enter_test_case(self, test_case):
sys.stdout.write(
as_emphasised( "\nRunning Test Case [%s] ...\n" % test_case['key'] )
)
test_case['timer'] = cuppa.timer.Timer()
def enter_suite(self, suite):
sys.stdout.write(as_emphasised("\nStarting Test Suite [%s]\n" % suite))
def write( text ):
if not emphasise:
sys.stdout.write( text )
else:
sys.stdout.write( as_emphasised( text ) )
def summary( self, returncode ):
summary = self._toolchain_processor.summary( returncode )
if returncode and not self._verbose_build:
summary += "\nTry running with {} for more details".format( as_emphasised( '--boost-verbose-build' ) )
return summary
def exit_suite(self, suite):
sys.stdout.write(
as_emphasised( "\nTest Suite Finished [%s] " % suite['name'] )
)
passed_tests = suite['passed_tests']
failed_tests = suite['failed_tests']
expected_failures = suite['expected_failures']
skipped_tests = suite['skipped_tests']
aborted_tests = suite['aborted_tests']
total_assertions = suite['total_assertions']
passed_assertions = suite['passed_assertions']
warned_assertions = suite['warned_assertions']
failed_assertions = suite['failed_assertions']
label = suite['status'].upper()
meaning = suite['status']
if meaning == 'passed' and warned_assertions:
meaning = 'warning'
sys.stdout.write(
as_highlighted( meaning, " = {} = ".format( suite['status'].upper() ) )
)
sys.stdout.write('\n')
sys.stdout.write(
as_emphasised( "\nSummary\n" )
)
for test in suite['tests']:
sys.stdout.write(
as_emphasised( "\nTest case [{}]".format( test['name'] ) ) + '\n'
)
self._write_test_case( test )
sys.stdout.write('\n')
sys.stdout.write(
as_highlighted( meaning, " = %s = " % label )
)
cuppa.timer.write_time( suite['total_cpu_times'] )
if total_assertions > 0:
if suite['status'] == 'passed':
if not warned_assertions:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Assertions Passed )" % (passed_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s Passed + %s Warned out of %s Assertions Passed )" % (passed_assertions, warned_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Assertions Failed )" % (failed_assertions, total_assertions)
)
)
else:
sys.stdout.write(
as_colour(
'notice',
" ( No Assertions Checked )"
)
)
if suite['status'] == 'passed' and passed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Passed ) "
% (passed_tests, passed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
elif suite['status'] != 'passed':
self.master_suite['status'] = 'failed'
if failed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Failed ) "
% (failed_tests, failed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if expected_failures > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Expected ) "
% (expected_failures, expected_failures > 1 and 'Failures' or 'Failure')
)
)
if len( skipped_tests ):
number = len( skipped_tests )
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Skipped ) "
% (number, number > 1 and 'Test Cases' or 'Test Case')
)
)
if aborted_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Aborted ) "
% (aborted_tests, aborted_tests > 1 and 'Test Cases Were' or 'Test Case Was')
)
)
sys.stdout.write( '\n\n')
def __init__( self,
base_path = os.path.abspath( '.' ),
branch_root = None,
default_options = {},
default_projects = [],
default_variants = [],
default_dependencies = [],
default_profiles = [],
default_runner = None,
configure_callback = None,
dependencies = {},
tools = [] ):
cuppa.version.check_current_version()
set_base_options()
initialise_logging()
cuppa_env = CuppaEnvironment()
cuppa_env.add_tools( tools )
self.initialise_options( cuppa_env, default_options, dependencies )
cuppa_env['configured_options'] = {}
self._configure = cuppa.configure.Configure( cuppa_env, callback=configure_callback )
verbosity = cuppa_env.get_option( 'verbosity' )
if verbosity:
set_logging_level( verbosity )
cuppa_env['sconstruct_file'] = cuppa_env.get_option( 'file' )
if not cuppa_env['sconstruct_file']:
for path in [ 'SConstruct', 'Sconstruct', 'sconstruct' ]:
if os.path.exists( path ):
cuppa_env['sconstruct_file'] = path
cuppa_env['raw_output'] = cuppa_env.get_option( 'raw_output' ) and True or False
cuppa_env['standard_output'] = cuppa_env.get_option( 'standard_output' ) and True or False
if not cuppa_env['raw_output'] and not cuppa_env['standard_output']:
cuppa_env.colouriser().enable()
reset_logging_format()
logger.info( "using sconstruct file [{}]".format( as_notice( cuppa_env['sconstruct_file'] ) ) )
help = cuppa_env.get_option( 'help' ) and True or False
self._configure.load()
cuppa_env['minimal_output'] = cuppa_env.get_option( 'minimal_output' )
cuppa_env['ignore_duplicates'] = cuppa_env.get_option( 'ignore_duplicates' )
cuppa_env['working_dir'] = os.getcwd()
cuppa_env['launch_dir'] = os.path.relpath( SCons.Script.GetLaunchDir(), cuppa_env['working_dir'] )
cuppa_env['run_from_launch_dir'] = cuppa_env['launch_dir'] == "."
cuppa_env['launch_offset_dir'] = "."
if not cuppa_env['run_from_launch_dir']:
levels = len( cuppa_env['launch_dir'].split( os.path.sep ) )
cuppa_env['launch_offset_dir'] = os.path.sep.join( ['..' for i in range(levels)] )
cuppa_env['base_path'] = os.path.normpath( os.path.expanduser( base_path ) )
cuppa_env['branch_root'] = branch_root and os.path.normpath( os.path.expanduser( branch_root ) ) or base_path
cuppa_env['branch_dir'] = cuppa_env['branch_root'] and os.path.relpath( cuppa_env['base_path'], cuppa_env['branch_root'] ) or None
thirdparty = cuppa_env.get_option( 'thirdparty' )
if thirdparty:
thirdparty = os.path.normpath( os.path.expanduser( thirdparty ) )
cuppa_env['thirdparty'] = thirdparty
build_root = cuppa_env.get_option( 'build_root', default='_build' )
cuppa_env['build_root'] = os.path.normpath( os.path.expanduser( build_root ) )
download_root = cuppa_env.get_option( 'download_root', default='_cuppa' )
cuppa_env['download_root'] = os.path.normpath( os.path.expanduser( download_root ) )
cache_root = cuppa_env.get_option( 'cache_root', default='~/_cuppa/_cache' )
cuppa_env['cache_root'] = os.path.normpath( os.path.expanduser( cache_root ) )
if not os.path.exists( cuppa_env['cache_root'] ):
os.makedirs( cuppa_env['cache_root'] )
cuppa_env['default_projects'] = default_projects
cuppa_env['default_variants'] = default_variants and set( default_variants ) or set()
cuppa_env['default_dependencies'] = default_dependencies and default_dependencies or []
cuppa_env['BUILD_WITH'] = cuppa_env['default_dependencies']
cuppa_env['dependencies'] = {}
cuppa_env['default_profiles'] = default_profiles and default_profiles or []
cuppa_env['BUILD_PROFILE'] = cuppa_env['default_profiles']
cuppa_env['profiles'] = {}
test_runner = cuppa_env.get_option( 'runner', default=default_runner and default_runner or 'process' )
cuppa_env['default_runner'] = test_runner
cuppa_env['show_test_output'] = cuppa_env.get_option( 'show-test-output' ) and True or False
self.add_variants ( cuppa_env )
self.add_toolchains ( cuppa_env )
self.add_platforms ( cuppa_env )
cuppa_env['platform'] = cuppa.build_platform.Platform.current()
toolchains = cuppa_env.get_option( 'toolchains' )
cuppa_env[ 'target_architectures' ] = None
if not help and not self._configure.handle_conf_only():
default_toolchain = cuppa_env['platform'].default_toolchain()
if not toolchains:
toolchains = [ cuppa_env[self.toolchains_key][default_toolchain] ]
else:
toolchains = [ cuppa_env[self.toolchains_key][t] for t in toolchains ]
cuppa_env['active_toolchains'] = toolchains
def add_dependency( name, dependency ):
cuppa_env['dependencies'][name] = dependency
cuppa.modules.registration.get_options( "methods", cuppa_env )
if not help and not self._configure.handle_conf_only():
cuppa_env[self.project_generators_key] = {}
cuppa.modules.registration.add_to_env( "dependencies", cuppa_env, add_dependency )
cuppa.modules.registration.add_to_env( "profiles", cuppa_env )
cuppa.modules.registration.add_to_env( "methods", cuppa_env )
cuppa.modules.registration.add_to_env( "project_generators", cuppa_env )
for method_plugin in pkg_resources.iter_entry_points( group='cuppa.method.plugins', name=None ):
method_plugin.load().add_to_env( cuppa_env )
if dependencies:
for name, dependency in dependencies.iteritems():
dependency.add_to_env( cuppa_env, add_dependency )
# TODO - default_profile
if cuppa_env.get_option( 'dump' ):
cuppa_env.dump()
SCons.Script.Exit()
job_count = cuppa_env.get_option( 'num_jobs' )
parallel = cuppa_env.get_option( 'parallel' )
parallel_mode = "manually"
if job_count==1 and parallel:
job_count = multiprocessing.cpu_count()
if job_count > 1:
SCons.Script.SetOption( 'num_jobs', job_count )
parallel_mode = "automatically"
cuppa_env['job_count'] = job_count
cuppa_env['parallel'] = parallel
if job_count>1:
logger.debug( "Running in {} with option [{}] set {} as [{}]".format(
as_emphasised("parallel mode"),
as_info( "jobs" ),
as_emphasised(parallel_mode),
as_info( str( SCons.Script.GetOption( 'num_jobs') ) )
) )
if not help and self._configure.handle_conf_only():
self._configure.save()
if not help and not self._configure.handle_conf_only():
self.build( cuppa_env )
if self._configure.handle_conf_only():
print "cuppa: Handling onfiguration only, so no builds will be attempted."
print "cuppa: With the current configuration executing 'scons -D' would be equivalent to:"
print ""
print "scons -D {}".format( self._command_line_from_settings( cuppa_env['configured_options'] ) )
print ""
print "cuppa: Nothing to be done. Exiting."
SCons.Script.Exit()
def exit_suite( self ):
suite = self._suite
total_tests = suite['total_tests']
passed_tests = suite['passed_tests'] + suite['expected_failures'] + suite['skipped_tests']
failed_tests = suite['failed_tests'] + suite['aborted_tests']
expected_failures = suite['expected_failures']
skipped_tests = suite['skipped_tests']
aborted_tests = suite['aborted_tests']
suite['status'] = 'passed'
meaning = 'passed'
if total_tests != passed_tests:
suite['status'] = 'failed'
meaning = 'failed'
sys.stdout.write(
as_emphasised( "\nTest Suite [{}] ".format( self._name ) )
)
sys.stdout.write(
as_highlighted( meaning, " = {} = ".format( suite['status'].upper() ) )
)
sys.stdout.write('\n')
sys.stdout.write(
as_emphasised( "\nSummary\n" )
)
for test in self._tests:
sys.stdout.write(
as_emphasised( "\nTest case [{}]".format( test['name'] ) ) + '\n'
)
self._write_test_case( test )
sys.stdout.write('\n\n')
if total_tests > 0:
if suite['status'] == 'passed':
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Test Cases Passed )" % ( passed_tests, total_tests )
)
)
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s of %s Test Cases Failed )" % (failed_tests, total_tests)
)
)
else:
sys.stdout.write(
as_colour(
'notice',
" ( No Test Cases Checked )"
)
)
if passed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Passed ) "
% (passed_tests, passed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if failed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Failed ) "
% (failed_tests, failed_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if expected_failures > 0:
meaning = 'expected_failure'
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Expected ) "
% (expected_failures, expected_failures > 1 and 'Failures' or 'Failure')
)
)
if skipped_tests > 0:
meaning = 'skipped'
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Skipped ) "
% (skipped_tests, skipped_tests > 1 and 'Test Cases' or 'Test Case')
)
)
if aborted_tests > 0:
meaning = 'aborted'
sys.stdout.write(
as_highlighted(
meaning,
" ( %s %s Aborted ) "
% (aborted_tests, aborted_tests > 1 and 'Test Cases Were' or 'Test Case Was')
)
)
sys.stdout.write('\n')
cuppa.timer.write_time( self._suite['total_cpu_times'], True )
self._tests = []
self._suite = {}
sys.stdout.write('\n\n')
def enter_test(self, test_case):
pass
sys.stdout.write(
as_emphasised( "\nRunning Test Case [%s] ...\n" % test_case )
)
def __init__(self,
sconstruct_path,
base_path=os.path.abspath('.'),
branch_root=None,
default_options={},
default_projects=[],
default_variants=[],
default_dependencies=[],
default_profiles=[],
dependencies=[],
profiles=[],
default_runner=None,
configure_callback=None,
tools=[]):
cuppa.core.base_options.set_base_options()
cuppa_env = cuppa.core.environment.CuppaEnvironment()
cuppa_env.add_tools(tools)
dependencies, default_dependencies, dependencies_warning = self._normalise_with_defaults(
dependencies, default_dependencies, "dependencies")
profiles, default_profiles, profiles_warning = self._normalise_with_defaults(
profiles, default_profiles, "profiles")
self.initialise_options(cuppa_env, default_options, profiles,
dependencies)
cuppa_env['configured_options'] = {}
self._configure = cuppa.configure.Configure(
cuppa_env, callback=configure_callback)
enable_thirdparty_logging(
cuppa_env.get_option('enable-thirdparty-logging') and True
or False)
self._set_verbosity_level(cuppa_env)
cuppa_env['sconstruct_path'] = sconstruct_path
cuppa_env['sconstruct_dir'], cuppa_env[
'sconstruct_file'] = os.path.split(sconstruct_path)
self._set_output_format(cuppa_env)
self._configure.load()
cuppa_env['offline'] = cuppa_env.get_option('offline')
cuppa.version.check_current_version(cuppa_env['offline'])
if cuppa_env['offline']:
logger.info(as_info_label("Running in OFFLINE mode"))
logger.info("using sconstruct file [{}]".format(
as_notice(cuppa_env['sconstruct_file'])))
if dependencies_warning:
logger.warn(dependencies_warning)
if profiles_warning:
logger.warn(profiles_warning)
help = cuppa_env.get_option('help') and True or False
cuppa_env['minimal_output'] = cuppa_env.get_option('minimal_output')
cuppa_env['ignore_duplicates'] = cuppa_env.get_option(
'ignore_duplicates')
cuppa_env['working_dir'] = os.getcwd()
cuppa_env['launch_dir'] = os.path.relpath(SCons.Script.GetLaunchDir(),
cuppa_env['working_dir'])
cuppa_env['run_from_launch_dir'] = cuppa_env['launch_dir'] == "."
cuppa_env['launch_offset_dir'] = "."
if not cuppa_env['run_from_launch_dir']:
levels = len(cuppa_env['launch_dir'].split(os.path.sep))
cuppa_env['launch_offset_dir'] = os.path.sep.join(
['..' for i in range(levels)])
cuppa_env['base_path'] = os.path.normpath(
os.path.expanduser(base_path))
cuppa_env['branch_root'] = branch_root and os.path.normpath(
os.path.expanduser(branch_root)) or base_path
cuppa_env['branch_dir'] = cuppa_env['branch_root'] and os.path.relpath(
cuppa_env['base_path'], cuppa_env['branch_root']) or None
thirdparty = cuppa_env.get_option('thirdparty')
if thirdparty:
thirdparty = os.path.normpath(os.path.expanduser(thirdparty))
cuppa_env['thirdparty'] = thirdparty
cuppa.core.storage_options.process_storage_options(cuppa_env)
cuppa.core.location_options.process_location_options(cuppa_env)
cuppa_env['current_branch'] = ''
cuppa_env['current_revision'] = ''
if not help and not self._configure.handle_conf_only():
if cuppa_env['location_match_current_branch']:
url, repo, branch, remote, rev = cuppa.scms.scms.get_current_rev_info(
cuppa_env['sconstruct_dir'])
if branch:
cuppa_env['current_branch'] = branch
if rev:
cuppa_env['current_revision'] = rev
logger.info(
"Current build on branch [{}] at revision [{}] from remote [{}] in [{}] at [{}]"
.format(as_info(str(branch)), as_info(str(rev)),
as_info(str(remote)), as_info(str(repo)),
as_info(str(url))))
cuppa_env['default_projects'] = default_projects
cuppa_env['default_variants'] = default_variants and set(
default_variants) or set()
cuppa_env['default_dependencies'] = default_dependencies and default_dependencies or []
cuppa_env['BUILD_WITH'] = cuppa_env['default_dependencies']
cuppa_env['dependencies'] = {}
cuppa_env[
'default_profiles'] = default_profiles and default_profiles or []
cuppa_env['BUILD_PROFILE'] = cuppa_env['default_profiles']
cuppa_env['profiles'] = {}
test_runner = cuppa_env.get_option(
'runner', default=default_runner and default_runner or 'process')
cuppa_env['default_runner'] = test_runner
cuppa_env['propagate_env'] = cuppa_env.get_option(
'propagate-env') and True or False
cuppa_env['propagate_path'] = cuppa_env.get_option(
'propagate-path') and True or False
cuppa_env['merge_path'] = cuppa_env.get_option(
'merge-path') and True or False
cuppa_env['show_test_output'] = cuppa_env.get_option(
'show-test-output') and True or False
cuppa_env['suppress_process_output'] = cuppa_env.get_option(
'suppress-process-output') and True or False
cuppa_env['dump'] = cuppa_env.get_option('dump') and True or False
cuppa_env['clean'] = cuppa_env.get_option('clean') and True or False
self.add_variants(cuppa_env)
self.add_toolchains(cuppa_env)
self.add_platforms(cuppa_env)
cuppa_env['platform'] = cuppa.build_platform.Platform.current()
toolchains = cuppa_env.get_option('toolchains')
cuppa_env['target_architectures'] = None
if not help and not self._configure.handle_conf_only():
default_toolchain = cuppa_env['platform'].default_toolchain()
if not toolchains:
toolchains = [
cuppa_env[self.toolchains_key][default_toolchain]
]
else:
toolchains = [
cuppa_env[self.toolchains_key][t] for t in toolchains
]
cuppa_env['active_toolchains'] = toolchains
def add_profile(name, profile):
cuppa_env['profiles'][name] = profile
def add_dependency(name, dependency):
cuppa_env['dependencies'][name] = dependency
cuppa.modules.registration.get_options("methods", cuppa_env)
if not help and not self._configure.handle_conf_only():
cuppa_env[self.project_generators_key] = {}
cuppa.modules.registration.add_to_env("dependencies",
cuppa_env,
add_dependency)
cuppa.modules.registration.add_to_env("profiles", cuppa_env,
add_profile)
cuppa.modules.registration.add_to_env("methods", cuppa_env)
cuppa.modules.registration.add_to_env("project_generators",
cuppa_env)
for method_plugin in pkg_resources.iter_entry_points(
group='cuppa.method.plugins', name=None):
method_plugin.load().add_to_env(cuppa_env)
for profile_plugin in pkg_resources.iter_entry_points(
group='cuppa.profile.plugins', name=None):
profile_plugin.load().add_to_env(cuppa_env)
if profiles:
for profile in profiles:
profile.add_to_env(cuppa_env, add_profile)
logger.trace("available profiles are [{}]".format(
colour_items(sorted(cuppa_env["profiles"].keys()))))
logger.info("default profiles are [{}]".format(
colour_items(sorted(cuppa_env["default_profiles"]),
as_info)))
for dependency_plugin in pkg_resources.iter_entry_points(
group='cuppa.dependency.plugins', name=None):
dependency_plugin.load().add_to_env(
cuppa_env, add_dependency)
if dependencies:
for dependency in dependencies:
dependency.add_to_env(cuppa_env, add_dependency)
logger.trace("available dependencies are [{}]".format(
colour_items(sorted(cuppa_env["dependencies"].keys()))))
logger.info("default dependencies are [{}]".format(
colour_items(sorted(cuppa_env["default_dependencies"]),
as_info)))
# TODO - default_profile
if cuppa_env['dump']:
logger.info(
as_info_label(
"Running in DUMP mode, no building will be attempted"))
cuppa_env.dump()
job_count = cuppa_env.get_option('num_jobs')
parallel = cuppa_env.get_option('parallel')
parallel_mode = "manually"
if job_count == 1 and parallel:
job_count = multiprocessing.cpu_count()
if job_count > 1:
SCons.Script.SetOption('num_jobs', job_count)
parallel_mode = "automatically"
cuppa_env['job_count'] = job_count
cuppa_env['parallel'] = parallel
if job_count > 1:
logger.info(
"Running in {} with option [{}] set {} as [{}]".format(
as_emphasised("parallel mode"), as_info("jobs"),
as_emphasised(parallel_mode),
as_info(str(SCons.Script.GetOption('num_jobs')))))
if not help and self._configure.handle_conf_only():
self._configure.save()
if not help and not self._configure.handle_conf_only():
self.build(cuppa_env)
if self._configure.handle_conf_only():
print(
"cuppa: Handling configuration only, so no builds will be attempted."
)
print(
"cuppa: With the current configuration executing 'scons -D' would be equivalent to:"
)
print("")
print("scons -D {}".format(
self._command_line_from_settings(
cuppa_env['configured_options'])))
print("")
print("cuppa: Nothing to be done. Exiting.")
SCons.Script.Exit()
def exit_suite(self):
suite = self._suite
total_tests = suite['total_tests']
passed_tests = suite['passed_tests'] + suite[
'expected_failures'] + suite['skipped_tests']
failed_tests = suite['failed_tests'] + suite['aborted_tests']
expected_failures = suite['expected_failures']
skipped_tests = suite['skipped_tests']
aborted_tests = suite['aborted_tests']
suite['status'] = 'passed'
meaning = 'passed'
if total_tests != passed_tests:
suite['status'] = 'failed'
meaning = 'failed'
sys.stdout.write(as_emphasised("\nTest Suite [{}] ".format(
self._name)))
sys.stdout.write(
as_highlighted(meaning,
" = {} = ".format(suite['status'].upper())))
sys.stdout.write('\n')
sys.stdout.write(as_emphasised("\nSummary\n"))
for test in self._tests:
sys.stdout.write(
as_emphasised("\nTest case [{}]".format(test['name'])) + '\n')
self._write_test_case(test)
sys.stdout.write('\n\n')
if total_tests > 0:
if suite['status'] == 'passed':
sys.stdout.write(
as_highlighted(
meaning, " ( %s of %s Test Cases Passed )" %
(passed_tests, total_tests)))
else:
sys.stdout.write(
as_highlighted(
meaning, " ( %s of %s Test Cases Failed )" %
(failed_tests, total_tests)))
else:
sys.stdout.write(as_colour('notice', " ( No Test Cases Checked )"))
if passed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Passed ) " %
(passed_tests, passed_tests > 1 and 'Test Cases'
or 'Test Case')))
if failed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Failed ) " %
(failed_tests, failed_tests > 1 and 'Test Cases'
or 'Test Case')))
if expected_failures > 0:
meaning = 'expected_failure'
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Expected ) " %
(expected_failures, expected_failures > 1 and 'Failures'
or 'Failure')))
if skipped_tests > 0:
meaning = 'skipped'
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Skipped ) " %
(skipped_tests, skipped_tests > 1 and 'Test Cases'
or 'Test Case')))
if aborted_tests > 0:
meaning = 'aborted'
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Aborted ) " %
(aborted_tests, aborted_tests > 1 and 'Test Cases Were'
or 'Test Case Was')))
sys.stdout.write('\n')
cuppa.timer.write_time(self._suite['total_cpu_times'], True)
self._tests = []
self._suite = {}
sys.stdout.write('\n\n')
def enter_test(self, test_case):
sys.stdout.write(
as_emphasised("\nRunning Test Case [%s] ...\n" % test_case['key']))
def __init__( self,
sconstruct_path,
base_path = os.path.abspath( '.' ),
branch_root = None,
default_options = {},
default_projects = [],
default_variants = [],
default_dependencies = [],
default_profiles = [],
dependencies = [],
profiles = [],
default_runner = None,
configure_callback = None,
tools = [] ):
cuppa.core.base_options.set_base_options()
cuppa_env = cuppa.core.environment.CuppaEnvironment()
cuppa_env.add_tools( tools )
dependencies, default_dependencies, dependencies_warning = self._normalise_with_defaults( dependencies, default_dependencies, "dependencies" )
profiles, default_profiles, profiles_warning = self._normalise_with_defaults( profiles, default_profiles, "profiles" )
self.initialise_options( cuppa_env, default_options, profiles, dependencies )
cuppa_env['configured_options'] = {}
self._configure = cuppa.configure.Configure( cuppa_env, callback=configure_callback )
enable_thirdparty_logging( cuppa_env.get_option( 'enable-thirdparty-logging' ) and True or False )
self._set_verbosity_level( cuppa_env )
cuppa_env['sconstruct_path'] = sconstruct_path
cuppa_env['sconstruct_dir'], cuppa_env['sconstruct_file'] = os.path.split(sconstruct_path)
self._set_output_format( cuppa_env )
self._configure.load()
cuppa_env['offline'] = cuppa_env.get_option( 'offline' )
cuppa.version.check_current_version( cuppa_env['offline'] )
if cuppa_env['offline']:
logger.info( as_info_label( "Running in OFFLINE mode" ) )
logger.info( "using sconstruct file [{}]".format( as_notice( cuppa_env['sconstruct_file'] ) ) )
if dependencies_warning:
logger.warn( dependencies_warning )
if profiles_warning:
logger.warn( profiles_warning )
help = cuppa_env.get_option( 'help' ) and True or False
cuppa_env['minimal_output'] = cuppa_env.get_option( 'minimal_output' )
cuppa_env['ignore_duplicates'] = cuppa_env.get_option( 'ignore_duplicates' )
cuppa_env['working_dir'] = os.getcwd()
cuppa_env['launch_dir'] = os.path.relpath( SCons.Script.GetLaunchDir(), cuppa_env['working_dir'] )
cuppa_env['run_from_launch_dir'] = cuppa_env['launch_dir'] == "."
cuppa_env['launch_offset_dir'] = "."
if not cuppa_env['run_from_launch_dir']:
levels = len( cuppa_env['launch_dir'].split( os.path.sep ) )
cuppa_env['launch_offset_dir'] = os.path.sep.join( ['..' for i in range(levels)] )
cuppa_env['base_path'] = os.path.normpath( os.path.expanduser( base_path ) )
cuppa_env['branch_root'] = branch_root and os.path.normpath( os.path.expanduser( branch_root ) ) or base_path
cuppa_env['branch_dir'] = cuppa_env['branch_root'] and os.path.relpath( cuppa_env['base_path'], cuppa_env['branch_root'] ) or None
thirdparty = cuppa_env.get_option( 'thirdparty' )
if thirdparty:
thirdparty = os.path.normpath( os.path.expanduser( thirdparty ) )
cuppa_env['thirdparty'] = thirdparty
cuppa.core.storage_options.process_storage_options( cuppa_env )
cuppa.core.location_options.process_location_options( cuppa_env )
cuppa_env['default_projects'] = default_projects
cuppa_env['default_variants'] = default_variants and set( default_variants ) or set()
cuppa_env['default_dependencies'] = default_dependencies and default_dependencies or []
cuppa_env['BUILD_WITH'] = cuppa_env['default_dependencies']
cuppa_env['dependencies'] = {}
cuppa_env['default_profiles'] = default_profiles and default_profiles or []
cuppa_env['BUILD_PROFILE'] = cuppa_env['default_profiles']
cuppa_env['profiles'] = {}
test_runner = cuppa_env.get_option( 'runner', default=default_runner and default_runner or 'process' )
cuppa_env['default_runner'] = test_runner
cuppa_env['propagate_env'] = cuppa_env.get_option( 'propagate-env' ) and True or False
cuppa_env['propagate_path'] = cuppa_env.get_option( 'propagate-path' ) and True or False
cuppa_env['merge_path'] = cuppa_env.get_option( 'merge-path' ) and True or False
cuppa_env['show_test_output'] = cuppa_env.get_option( 'show-test-output' ) and True or False
cuppa_env['suppress_process_output'] = cuppa_env.get_option( 'suppress-process-output' ) and True or False
cuppa_env['dump'] = cuppa_env.get_option( 'dump' ) and True or False
cuppa_env['clean'] = cuppa_env.get_option( 'clean' ) and True or False
self.add_variants ( cuppa_env )
self.add_toolchains ( cuppa_env )
self.add_platforms ( cuppa_env )
cuppa_env['platform'] = cuppa.build_platform.Platform.current()
toolchains = cuppa_env.get_option( 'toolchains' )
cuppa_env[ 'target_architectures' ] = None
if not help and not self._configure.handle_conf_only():
default_toolchain = cuppa_env['platform'].default_toolchain()
if not toolchains:
toolchains = [ cuppa_env[self.toolchains_key][default_toolchain] ]
else:
toolchains = [ cuppa_env[self.toolchains_key][t] for t in toolchains ]
cuppa_env['active_toolchains'] = toolchains
def add_profile( name, profile ):
cuppa_env['profiles'][name] = profile
def add_dependency( name, dependency ):
cuppa_env['dependencies'][name] = dependency
cuppa.modules.registration.get_options( "methods", cuppa_env )
if not help and not self._configure.handle_conf_only():
cuppa_env[self.project_generators_key] = {}
cuppa.modules.registration.add_to_env( "dependencies", cuppa_env, add_dependency )
cuppa.modules.registration.add_to_env( "profiles", cuppa_env, add_profile )
cuppa.modules.registration.add_to_env( "methods", cuppa_env )
cuppa.modules.registration.add_to_env( "project_generators", cuppa_env )
for method_plugin in pkg_resources.iter_entry_points( group='cuppa.method.plugins', name=None ):
method_plugin.load().add_to_env( cuppa_env )
for profile_plugin in pkg_resources.iter_entry_points( group='cuppa.profile.plugins', name=None ):
profile_plugin.load().add_to_env( cuppa_env )
if profiles:
for profile in profiles:
profile.add_to_env( cuppa_env, add_profile )
logger.trace( "available profiles are [{}]".format(
colour_items( sorted( cuppa_env["profiles"].keys() ) )
) )
logger.info( "default profiles are [{}]".format(
colour_items( sorted( cuppa_env["default_profiles"] ), as_info )
) )
for dependency_plugin in pkg_resources.iter_entry_points( group='cuppa.dependency.plugins', name=None ):
dependency_plugin.load().add_to_env( cuppa_env, add_dependency )
if dependencies:
for dependency in dependencies:
dependency.add_to_env( cuppa_env, add_dependency )
logger.trace( "available dependencies are [{}]".format(
colour_items( sorted( cuppa_env["dependencies"].keys() ) )
) )
logger.info( "default dependencies are [{}]".format(
colour_items( sorted( cuppa_env["default_dependencies"] ), as_info )
) )
# TODO - default_profile
if cuppa_env['dump']:
logger.info( as_info_label( "Running in DUMP mode, no building will be attempted" ) )
cuppa_env.dump()
job_count = cuppa_env.get_option( 'num_jobs' )
parallel = cuppa_env.get_option( 'parallel' )
parallel_mode = "manually"
if job_count==1 and parallel:
job_count = multiprocessing.cpu_count()
if job_count > 1:
SCons.Script.SetOption( 'num_jobs', job_count )
parallel_mode = "automatically"
cuppa_env['job_count'] = job_count
cuppa_env['parallel'] = parallel
if job_count>1:
logger.debug( "Running in {} with option [{}] set {} as [{}]".format(
as_emphasised("parallel mode"),
as_info( "jobs" ),
as_emphasised(parallel_mode),
as_info( str( SCons.Script.GetOption( 'num_jobs') ) )
) )
if not help and self._configure.handle_conf_only():
self._configure.save()
if not help and not self._configure.handle_conf_only():
self.build( cuppa_env )
if self._configure.handle_conf_only():
print "cuppa: Handling configuration only, so no builds will be attempted."
print "cuppa: With the current configuration executing 'scons -D' would be equivalent to:"
print ""
print "scons -D {}".format( self._command_line_from_settings( cuppa_env['configured_options'] ) )
print ""
print "cuppa: Nothing to be done. Exiting."
SCons.Script.Exit()
def exit_suite(self, suite):
sys.stdout.write(
as_emphasised("\nTest Suite Finished [%s] " % suite['name']))
total_tests = int(suite['total_tests'])
passed_tests = int(suite['passed_tests'])
failed_tests = int(suite['failed_tests'])
expected_failures = int(suite['expected_failures'])
skipped_tests = int(suite['skipped_tests'])
aborted_tests = int(suite['aborted_tests'])
total_assertions = int(suite['total_assertions'])
passed_assertions = int(suite['passed_assertions'])
warned_assertions = int(suite['warned_assertions'])
failed_assertions = int(suite['failed_assertions'])
label = suite['status'].upper()
meaning = suite['status']
if meaning == 'passed' and warned_assertions:
meaning = 'warning'
store_durations(suite)
sys.stdout.write(as_highlighted(meaning, " = %s = " % label))
self.__write_time(suite)
if total_assertions > 0:
if suite['status'] == 'passed':
if not warned_assertions:
sys.stdout.write(
as_highlighted(
meaning, " ( %s of %s Assertions Passed )" %
(passed_assertions, total_assertions)))
else:
sys.stdout.write(
as_highlighted(
meaning,
" ( %s Passed + %s Warned out of %s Assertions Passed )"
% (passed_assertions, warned_assertions,
total_assertions)))
else:
sys.stdout.write(
as_highlighted(
meaning, " ( %s of %s Assertions Failed )" %
(failed_assertions, total_assertions)))
else:
sys.stdout.write(as_colour('notice', " ( No Assertions Checked )"))
if suite['status'] == 'passed' and passed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Passed ) " %
(passed_tests, passed_tests > 1 and 'Test Cases'
or 'Test Case')))
elif suite['status'] != 'passed':
self.master_suite['status'] = 'failed'
if failed_tests > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Failed ) " %
(failed_tests, failed_tests > 1 and 'Test Cases'
or 'Test Case')))
if expected_failures > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Expected ) " %
(expected_failures, expected_failures > 1 and 'Failures'
or 'Failure')))
if skipped_tests > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Skipped ) " %
(skipped_tests, skipped_tests > 1 and 'Test Cases'
or 'Test Case')))
if aborted_tests > 0:
sys.stdout.write(
as_highlighted(
meaning, " ( %s %s Aborted ) " %
(aborted_tests, aborted_tests > 1 and 'Test Cases Were'
or 'Test Case Was')))
sys.stdout.write('\n\n')
def critical_fmt( cls ):
return "{} %(message)s".format( as_error_label( as_emphasised( "%(name)s: %(module)s: [%(levelname)s]") ) )