def handleUpdate(self, index, tr):
if self.progressBar:
if tr.failed():
self.progressBar.clear()
else:
# Force monotonicity
self.progress = max(self.progress, float(index)/self.numTests)
self.progressBar.update(self.progress, tr.path)
return
elif self.opts.succinct:
if not tr.failed():
sys.stdout.write('.')
sys.stdout.flush()
return
else:
sys.stdout.write('\n')
extra = ''
if tr.code==TestStatus.Invalid:
extra = ' - (Invalid test)'
elif tr.code==TestStatus.NoRunLine:
extra = ' - (No RUN line)'
elif tr.failed():
extra = ' - %s'%(TestStatus.getName(tr.code).upper(),)
print '%*d/%*d - %s%s'%(self.digits, index+1, self.digits,
self.numTests, tr.path, extra)
if tr.failed() and self.opts.showOutput:
TestRunner.cat(tr.testResults, sys.stdout)
def main():
''' main test logic '''
print("TestRunner.py - main")
if Configuration.DEBUG == True:
print("Debug messaging is ON")
logLevel = logging.DEBUG
else:
print("Debug messaging is OFF")
logLevel = logging.INFO
# setup logger
if not logFileFromBAT == None:
Configuration.Logger = UnitTestUtilities.initializeLogger(logFileFromBAT, logLevel)
else:
Configuration.GetLogger(logLevel)
print("Logging results to: " + str(Configuration.LoggerFile))
UnitTestUtilities.setUpLogFileHeader()
result = runTestSuite()
TestRunner.logTestResults(result)
return result.wasSuccessful()
def handleUpdate(self, index, tr):
if self.progressBar:
if tr.failed():
self.progressBar.clear()
else:
# Force monotonicity
self.progress = max(self.progress,
float(index) / self.numTests)
self.progressBar.update(self.progress, tr.path)
return
elif self.opts.succinct:
if not tr.failed():
sys.stdout.write('.')
sys.stdout.flush()
return
else:
sys.stdout.write('\n')
extra = ''
if tr.code == TestStatus.Invalid:
extra = ' - (Invalid test)'
elif tr.code == TestStatus.NoRunLine:
extra = ' - (No RUN line)'
elif tr.failed():
extra = ' - %s' % (TestStatus.getName(tr.code).upper(), )
print '%*d/%*d - %s%s' % (self.digits, index + 1, self.digits,
self.numTests, tr.path, extra)
if tr.failed() and self.opts.showOutput:
TestRunner.cat(tr.testResults, sys.stdout)
class Tester(threading.Thread):
def __init__(self, provider):
threading.Thread.__init__(self)
self.provider = provider
def run(self):
while 1:
item = self.provider.get()
if item is None:
break
self.runTest(item)
def runTest(self, (path, index)):
base = TestRunner.getTestOutputBase('Output', path)
numTests = len(self.provider.tests)
digits = len(str(numTests))
code = None
elapsed = None
try:
opts = self.provider.opts
startTime = time.time()
code, output = TestRunner.runOneTest(self.provider.config, path,
base)
elapsed = time.time() - startTime
except KeyboardInterrupt:
# This is a sad hack. Unfortunately subprocess goes
# bonkers with ctrl-c and we start forking merrily.
print '\nCtrl-C detected, goodbye.'
os.kill(0, 9)
self.provider.setResult(index, TestResult(path, code, output, elapsed))
def main():
''' main test logic '''
print("TestRunner.py - main")
if Configuration.DEBUG == True:
print("Debug messaging is ON")
logLevel = logging.DEBUG
else:
print("Debug messaging is OFF")
logLevel = logging.INFO
# setup logger
if not logFileFromBAT == None:
Configuration.Logger = UnitTestUtilities.initializeLogger(
logFileFromBAT, logLevel)
else:
Configuration.GetLogger(logLevel)
print("Logging results to: " + str(Configuration.LoggerFile))
UnitTestUtilities.setUpLogFileHeader()
result = runTestSuite()
TestRunner.logTestResults(result)
return result.wasSuccessful()
def execute(self, test, litConfig):
if test.config.unsupported:
return (Test.UNSUPPORTED, 'Test is unsupported')
cmd = list(self.command)
# If using temp input, create a temporary file and hand it to the
# subclass.
if self.useTempInput:
tmp = tempfile.NamedTemporaryFile(suffix='.cpp')
self.createTempInput(tmp, test)
tmp.flush()
cmd.append(tmp.name)
else:
cmd.append(test.source_path)
out, err, exitCode = TestRunner.executeCommand(cmd)
diags = out + err
if not exitCode and not diags.strip():
return Test.PASS, ''
# Try to include some useful information.
report = """Command: %s\n""" % ' '.join(["'%s'" % a for a in cmd])
if self.useTempInput:
report += """Temporary File: %s\n""" % tmp.name
report += "--\n%s--\n" "" % open(tmp.name).read()
report += """Output:\n--\n%s--""" % diags
return Test.FAIL, report
def execute(self, test, litConfig):
if test.config.unsupported:
return (Test.UNSUPPORTED, 'Test is unsupported')
cmd = list(self.command)
# If using temp input, create a temporary file and hand it to the
# subclass.
if self.useTempInput:
tmp = tempfile.NamedTemporaryFile(suffix='.cpp')
self.createTempInput(tmp, test)
tmp.flush()
cmd.append(tmp.name)
elif hasattr(test, 'source_path'):
cmd.append(test.source_path)
else:
cmd.append(test.getSourcePath())
out, err, exitCode = TestRunner.executeCommand(cmd)
diags = out + err
if not exitCode and not diags.strip():
return Test.PASS,''
# Try to include some useful information.
report = """Command: %s\n""" % ' '.join(["'%s'" % a
for a in cmd])
if self.useTempInput:
report += """Temporary File: %s\n""" % tmp.name
report += "--\n%s--\n""" % open(tmp.name).read()
report += """Output:\n--\n%s--""" % diags
return Test.FAIL, report
def handleUpdate(self, index, tr):
if self.progressBar:
if tr.failed():
self.progressBar.clear()
else:
# Force monotonicity
self.progress = max(self.progress, float(index)/self.numTests)
self.progressBar.update(self.progress, tr.path)
return
elif self.opts.succinct:
if not tr.failed():
sys.stdout.write('.')
sys.stdout.flush()
return
else:
sys.stdout.write('\n')
extra = ''
if tr.code==TestStatus.Invalid:
extra = ' - (Invalid test)'
elif tr.code==TestStatus.NoRunLine:
extra = ' - (No RUN line)'
elif tr.failed():
extra = ' - %s'%(TestStatus.getName(tr.code).upper(),)
print '%*d/%*d - %s%s'%(self.digits, index+1, self.digits,
self.numTests, tr.path, extra)
if tr.failed():
msgs = []
if tr.warnings:
msgs.append('%d warnings'%(len(tr.warnings),))
if tr.errors:
msgs.append('%d errors'%(len(tr.errors),))
if tr.assertions:
msgs.append('%d assertions'%(len(tr.assertions),))
if msgs:
print '\tFAIL (%s)'%(', '.join(msgs))
for i,error in enumerate(set([e for (_,_,_,e) in tr.errors])):
print '\t\tERROR: %s'%(error,)
if i>20:
print '\t\t\t(too many errors, skipping)'
break
for assertion in set(tr.assertions):
print '\t\tASSERTION: %s'%(assertion,)
if self.opts.showOutput:
TestRunner.cat(tr.testResults, sys.stdout)
def isLanguageSupported(language, compiler):
# How to run the compiler. Additional arguments are added below.
args = [compiler, '-S', '-o', os.devnull]
if language == 'java':
# GCC can't compile Java source by itself, it can only compile class files.
script_dir = os.path.dirname(os.path.realpath(__file__))
source = os.path.join(script_dir, 'e.class')
# Java is supported if the class file compiles without error.
out,err,exitCode = TestRunner.executeCommand(args +
[source, '-fuse-boehm-gc'])
return exitCode == 0
if language == 'ada':
suffix='.ads'
elif language == 'c':
suffix='.c'
elif language == 'c++':
suffix='.cpp'
elif language == 'fortran':
suffix='.f'
elif language == 'go':
suffix='.go'
elif language == 'objective-c':
suffix='.m'
elif language == 'objective-c++':
suffix='.mm'
else:
return False
# For most languages it suffices to try compiling an empty file however for
# Ada and Go an empty file is not a valid compilation unit.
source = tempfile.NamedTemporaryFile(mode='w+t', suffix=suffix)
if language == 'ada':
# Use an obscure package name, as if the package is called XYZ and a file
# called XYZ.adb exists then the test will fail.
source.write('package U5TE4J886W is end;\n')
elif language == 'go':
source.write('package main\n')
# If something was written then ensure it is visible to the compiler process.
source.flush()
# The language is supported if the file compiles without error.
out,err,exitCode = TestRunner.executeCommand(args + [source.name])
return exitCode == 0
def generateFortranModules(cmd, srcPath, OutputDir):
# Fortran 90 code often fails to compile because it needs modules defined by
# other files in the same directory. If this seems to be happening then try
# to generate all of the required modules by compiling every Fortran file in
# the same directory.
srcDir,srcBase = os.path.split(srcPath)
cmd = cmd + ['-I', srcDir, '-fsyntax-only']
# If the file compiles OK or isn't failing because of lacking modules then
# there is no point in trying to generate modules.
out,err,exitCode = TestRunner.executeCommand(cmd + [srcPath], OutputDir)
if exitCode == 0 or err is None or "Can't open module file" not in err:
return
# Drat, it fails to compile. Generate modules for every Fortran file in the
# source directory.
fortranSuffixes = DEUtils.getSuffixesForLanguage('fortran')
filesToCompile = []
for filename in os.listdir(srcDir):
filepath = os.path.join(srcDir, filename)
if not os.path.isdir(filepath):
base,ext = os.path.splitext(filename)
if ext in fortranSuffixes:
filesToCompile.append(filepath)
# Compile every file, returning triumphantly once the original file manages
# to compile, or giving up miserably if no progress is being made.
newFilesToCompile = []
while filesToCompile != newFilesToCompile:
newFilesToCompile = []
# Compile each file in turn.
for path in filesToCompile:
out,err,exitCode = TestRunner.executeCommand(cmd + [path], OutputDir)
if exitCode != 0 and err is not None and "Can't open module file" in err:
# It failed to compile due to a missing module. Remember it for
# the next round.
newFilesToCompile.append(path);
elif path == srcPath:
# The original file compiled, or at least didn't fail to compile
# due to a lacking module. Return triumphantly!
return
# Arrange for the next iteration to compile the files that were missing
# modules this time round.
filesToCompile, newFilesToCompile = newFilesToCompile, filesToCompile
# The set of files missing modules didn't change, give up miserably.
return
class Tester(threading.Thread):
def __init__(self, provider):
threading.Thread.__init__(self)
self.provider = provider
def run(self):
while 1:
item = self.provider.get()
if item is None:
break
self.runTest(item)
def runTest(self, (path, index)):
command = path
# Use hand concatentation here because we want to override
# absolute paths.
output = 'Output/' + path + '.out'
testname = path
testresults = 'Output/' + path + '.testresults'
TestRunner.mkdir_p(os.path.dirname(testresults))
numTests = len(self.provider.tests)
digits = len(str(numTests))
code = None
try:
opts = self.provider.opts
if opts.debugDoNotTest:
code = None
else:
code = TestRunner.runOneTest(path,
command,
output,
testname,
opts.clang,
useValgrind=opts.useValgrind,
useDGCompat=opts.useDGCompat,
useScript=opts.testScript,
output=open(testresults, 'w'))
except KeyboardInterrupt:
# This is a sad hack. Unfortunately subprocess goes
# bonkers with ctrl-c and we start forking merrily.
print 'Ctrl-C detected, goodbye.'
os.kill(0, 9)
self.provider.setResult(index, TestResult(path, code, testresults))
def execute(self, test, litConfig):
execdir = os.path.dirname(test.getExecPath())
tmpBase = self.getTmpBase(test, litConfig)
res = self.getTestScript(test, litConfig, self.default_script)
if len(res) == 2:
return res
s, script, isXFail = res
script = self.applyScriptSubstitutions(test, litConfig, script,
tmpBase, normalize_slashes=self.execute_external)
return TestRunner.executeShTest(test, litConfig, script,
isXFail, tmpBase, execdir,
self.execute_external)
def execute(self, test, litConfig):
testPath, testName = os.path.split(test.getSourcePath())
while not os.path.exists(testPath):
# Handle GTest parametrized and typed tests, whose name includes
# some '/'s.
testPath, namePrefix = os.path.split(testPath)
testName = os.path.join(namePrefix, testName)
cmd = [testPath, "--gtest_filter=" + testName]
out, err, exitCode = TestRunner.executeCommand(cmd)
if not exitCode:
return Test.PASS, ""
return Test.FAIL, out + err
def execute(self, test, litConfig):
testPath, testName = os.path.split(test.getSourcePath())
while not os.path.exists(testPath):
# Handle GTest parametrized and typed tests, whose name includes
# some '/'s.
testPath, namePrefix = os.path.split(testPath)
testName = os.path.join(namePrefix, testName)
cmd = [testPath, '--gtest_filter=' + testName]
out, err, exitCode = TestRunner.executeCommand(cmd)
if not exitCode:
return Test.PASS, ''
return Test.FAIL, out + err
def execute(self, test, litConfig):
litConfig.ignoreStdErr = self.ignoreStdErr
execdir = os.path.dirname(test.getExecPath())
tmpBase = self.getTmpBase(test, litConfig)
res = self.getTestScript(test, litConfig)
if len(res) == 2:
return res
s, script, isXFail = res
script = self.applyScriptSubstitutions(test, litConfig, script,
tmpBase, normalize_slashes=TestRunner.kIsWindows)
return TestRunner.executeTclTest(test, litConfig, script,
isXFail, tmpBase, execdir)
def execute(self, test, litConfig):
testPath,testName = os.path.split(test.getSourcePath())
while not os.path.exists(testPath):
# Handle GTest parametrized and typed tests, whose name includes
# some '/'s.
testPath, namePrefix = os.path.split(testPath)
testName = os.path.join(namePrefix, testName)
cmd = [testPath, '--gtest_filter=' + testName]
if litConfig.useValgrind:
cmd = litConfig.valgrindArgs + cmd
out, err, exitCode = TestRunner.executeCommand(
cmd, env=test.config.environment)
if not exitCode:
return Test.PASS,''
return Test.FAIL, out + err
def execute(self, test, litConfig):
testPath,testName = os.path.split(test.getSourcePath())
while not os.path.exists(testPath):
# Handle GTest parametrized and typed tests, whose name includes
# some '/'s.
testPath, namePrefix = os.path.split(testPath)
testName = os.path.join(namePrefix, testName)
cmd = [testPath, '--gtest_filter=' + testName]
if litConfig.useValgrind:
cmd = litConfig.valgrindArgs + cmd
if litConfig.noExecute:
return Test.PASS, ''
out, err, exitCode = TestRunner.executeCommand(
cmd, env=test.config.environment)
if not exitCode:
return Test.PASS,''
return Test.FAIL, out + err
def execute(self, test, litConfig):
if test.config.unsupported:
return (Test.UNSUPPORTED, 'Test is unsupported')
cmd = list(self.command)
# If using temp input, create a temporary file and hand it to the
# subclass.
if self.useTempInput:
tmp = tempfile.NamedTemporaryFile(suffix='.cpp')
self.createTempInput(tmp, test)
tmp.flush()
cmd.append(tmp.name)
elif hasattr(test, 'source_path'):
cmd.append(test.source_path)
else:
cmd.append(test.getSourcePath())
out, err, exitCode = TestRunner.executeCommand(cmd)
if not exitCode and (self.allowStdout or not out.strip()) and \
(self.allowStderr or not err.strip()):
status = Test.PASS
else:
status = Test.FAIL
if status == Test.FAIL or litConfig.showAllOutput:
# Try to include some useful information.
report = """Command: %s\n""" % ' '.join(["'%s'" % a
for a in cmd])
if self.useTempInput:
report += """Temporary File: %s\n""" % tmp.name
report += "--\n%s--\n""" % open(tmp.name).read()
report += """Command Output (stdout):\n--\n%s--\n""" % out
report += """Command Output (stderr):\n--\n%s--\n""" % err
else:
report = ""
return status, report
def dpdkick_main():
dpdkick_init()
if(globalvar.ENV_CONF_TYPE == "performance"):
hw_conf_test_suite = unittest.TestLoader().loadTestsFromTestCase(hwconftest.hwconftest)
sw_conf_test_suite = unittest.TestLoader().loadTestsFromTestCase(swconftest.swconftest)
kernel_conf_test_suite = unittest.TestLoader().loadTestsFromTestCase(kernelconftest.kernelconftest)
else:
print "Invalid DPDKick Configuration Type"
print "program exit.."
raise SystemExit
runner = TestRunner.TestRunner()
util.format_print_test_suite_title('Hardware Configuration Verification')
runner.run(hw_conf_test_suite, description = 'Hardware')
util.format_print_test_suite_title('Software Configuration and Runtime Verification')
runner.run(sw_conf_test_suite, description = 'Software')
util.format_print_test_suite_title('Kernel Configuration Verification')
runner.run(kernel_conf_test_suite, description = 'Kernel')
def execute(self, test, litConfig):
testPath,testName = os.path.split(test.getSourcePath())
while not os.path.exists(testPath):
# Handle GTest parametrized and typed tests, whose name includes
# some '/'s.
testPath, namePrefix = os.path.split(testPath)
testName = os.path.join(namePrefix, testName)
cmd = [testPath, '--gtest_filter=' + testName]
if litConfig.useValgrind:
valgrindArgs = ['valgrind', '-q',
'--tool=memcheck', '--trace-children=yes',
'--error-exitcode=123']
valgrindArgs.extend(litConfig.valgrindArgs)
cmd = valgrindArgs + cmd
out, err, exitCode = TestRunner.executeCommand(
cmd, env=test.config.environment)
if not exitCode:
return Test.PASS,''
return Test.FAIL, out + err
def execute(self, test, litConfig):
return TestRunner.executeShTest(test, litConfig,
self.execute_external)
parser.error(e.args[0])
cfg = TestingConfig.frompath(opts.config)
# Update the configuration based on the command line arguments.
for name in ('PATH','SYSTEMROOT'):
if name in cfg.environment:
parser.error("'%s' should not be set in configuration!" % name)
cfg.root = opts.root
cfg.environment['PATH'] = os.pathsep.join(opts.path +
[os.environ.get('PATH','')])
cfg.environment['SYSTEMROOT'] = os.environ.get('SYSTEMROOT','')
if opts.jlang is None:
opts.jlang = TestRunner.inferJlang(cfg)
if opts.jlangcc is None:
opts.jlangcc = TestRunner.inferJlangCC(cfg, opts.jlang)
cfg.jlang = opts.jlang
cfg.jlangcc = opts.jlangcc
cfg.useValgrind = opts.useValgrind
cfg.useExternalShell = opts.useExternalShell
# FIXME: It could be worth loading these in parallel with testing.
allTests = list(getTests(cfg, args))
allTests.sort()
tests = allTests
if opts.shuffle:
random.shuffle(tests)
def execute(self, test, litConfig):
return TestRunner.executeTclTest(test, litConfig)
def execute(self, test, litConfig):
return TestRunner.executeShTest(test, litConfig, self.execute_external)
def execute(self, test, litConfig):
litConfig.ignoreStdErr = self.ignoreStdErr
return TestRunner.executeTclTest(test, litConfig)
tests = [
("testExecs/iotest.exe", "", {}),
]
longTests = []
if __name__ == '__main__':
import sys
import TestRunner
failed, tests = TestRunner.RunScript('test_list.py', 0, 1)
sys.exit(len(failed))
_descriptionPath = os.path.join(_curentdatapath, "description.csv")
_dataPath = os.path.join(_curentdatapath, "data.csv")
# read description, it contain fiels named and field values. include clas column
description = pd.read_csv(_descriptionPath, dtype=str)
# create dictionary of fields and its values as a list
attDict = dict(
zip(list(description),
[_vlues.split(",")
for _vlues in (description.values.tolist()[0])]))
# load data and assign columns from description (nodelist)
data = pd.read_csv(_dataPath, names=list(attDict.keys()), dtype=str)
data = data.sample(frac=1).reset_index(drop=True)
PrunedMetrics = TestRunner.RunPrunedTreeTest(data, attDict, 0.2, 0.2)
trainTestMetrics = TestRunner.RunTrainTest(data, attDict, 0.66)
Fold3Metrics = TestRunner.RunKfold(data, attDict, 3)
Fold5Metrics = TestRunner.RunKfold(data, attDict, 5)
with open(os.path.join(_curentdatapath, "Results.txt"), "w") as text_file:
print("trainTestMetrics: {0},{1},{2}".format(*trainTestMetrics),
file=text_file)
print("Fold3Metrics: {0},{1},{2}".format(*Fold3Metrics),
file=text_file)
print("Fold5Metrics: {0},{1},{2}".format(*Fold5Metrics),
file=text_file)
print(
"BeforPruneMetrics: {0},{1},{2}, ".format(*PrunedMetrics[0]) +
parser.error(e.args[0])
cfg = TestingConfig.frompath(opts.config)
# Update the configuration based on the command line arguments.
for name in ('PATH', 'SYSTEMROOT'):
if name in cfg.environment:
parser.error("'%s' should not be set in configuration!" % name)
cfg.root = opts.root
cfg.environment['PATH'] = os.pathsep.join(opts.path +
[os.environ.get('PATH', '')])
cfg.environment['SYSTEMROOT'] = os.environ.get('SYSTEMROOT', '')
if opts.clang is None:
opts.clang = TestRunner.inferClang(cfg)
if opts.clangcc is None:
opts.clangcc = TestRunner.inferClangCC(cfg, opts.clang)
cfg.clang = opts.clang
cfg.clangcc = opts.clangcc
cfg.useValgrind = opts.useValgrind
cfg.useExternalShell = opts.useExternalShell
# FIXME: It could be worth loading these in parallel with testing.
allTests = list(getTests(cfg, args))
allTests.sort()
tests = allTests
if opts.shuffle:
random.shuffle(tests)
def execute(self, test, litConfig):
return TestRunner.executeTclTest(test, litConfig)
parser.error(e.args[0])
cfg = TestingConfig.frompath(opts.config)
# Update the configuration based on the command line arguments.
for name in ('PATH','SYSTEMROOT'):
if name in cfg.environment:
parser.error("'%s' should not be set in configuration!" % name)
cfg.root = opts.root
cfg.environment['PATH'] = os.pathsep.join(opts.path +
[os.environ.get('PATH','')])
cfg.environment['SYSTEMROOT'] = os.environ.get('SYSTEMROOT','')
if opts.clang is None:
opts.clang = TestRunner.inferClang(cfg)
if opts.clangcc is None:
opts.clangcc = TestRunner.inferClangCC(cfg, opts.clang)
cfg.clang = opts.clang
cfg.clangcc = opts.clangcc
cfg.useValgrind = opts.useValgrind
cfg.useExternalShell = opts.useExternalShell
# FIXME: It could be worth loading these in parallel with testing.
allTests = list(getTests(cfg, args))
allTests.sort()
tests = allTests
if opts.shuffle:
random.shuffle(tests)
def main(argv):
global config
global pbar
global test_index
lcfgPath = os.path.abspath(os.path.dirname(sys.argv[0])) + '\logging.cfg'
logging.config.fileConfig(lcfgPath,
defaults=None,
disable_existing_loggers=True)
logger = logging.getLogger(__name__)
logger.debug('Test Report Generator Validation')
# When this module is executed from the command line, run all its tests
try:
opts, args = getopt.getopt(sys.argv[1:], 'hc:v:r:m::x:s:', [
'help', 'config=', 'verbose=', 'report=', 'mode=', 'repeat=',
'suite='
])
except getopt.GetoptError as err:
# print help information and exit:
logger.error(
str(err)) # will print something like 'option -a not recognized
logger.error('option not recognized')
usage()
sys.exit(2)
mode = None
repeat = 1
report_fn = None
suite_fn = None
config_fn = None
config = None
for o, a in opts:
if o in ('-v', '--verbose'):
valid_levels = [
'NOTSET', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'
]
logger_levels = [
logging.NOTSET, logging.DEBUG, logging.INFO, logging.WARNING,
logging.ERROR, logging.CRITICAL
]
verbose_level = a
if verbose_level in valid_levels:
i = valid_levels.index(verbose_level)
logger.setLevel(logger_levels[i])
else:
usage()
sys.exit()
elif o in ('-h', '--help'):
usage()
sys.exit()
elif o in ('-c', '--config'):
config_fn = a
if os.path.exists(config_fn) is False:
logger.error('The specified config file %s does not exist' %
config_fn)
sys.exit(3)
elif o in ('-r', '--report'):
report_fn = a
elif o in ('-m', '--mode'):
mode = a
elif o in ('-x', '--repeat'):
repeat = int(a)
elif o in ('-s', '--suite'):
suite_fn = a
if os.path.exists(suite_fn) is False:
logger.error(
'The specified test suite file %s does not exist' %
suite_fn)
sys.exit(3)
else:
assert False, 'unhandled option'
#
# handle configuration if specified on command line
#
if config_fn:
logger.info('Handle configuration file')
config = configparser.ConfigParser()
try:
config.read(config_fn)
except:
logger.error('we failed')
logger.debug(config)
logger.debug(config.sections())
for c in config.sections():
logger.debug(c)
else:
logger.info('Handle command line args only')
if mode == 'HTML':
logger.info('use the TestReportGen module')
import TestRunner
res = []
with open('TestReportGenValidation_report.html', 'wb') as f:
runner = TestRunner.TestRunner(
stream=f,
verbosity=19,
title='Test Report Generator Validation',
description='Test Report Generator Validation HTML report')
for i in range(repeat):
r = runner.run(TestReportGenTestSuite(suite_fn), i)
res.append(r)
f.close()
else:
# do report in text mode with the eventual report file name option
logger.info('use Text mode')
if report_fn:
with open(report_fn, 'w', encoding='utf-8') as f:
for i in range(repeat):
unittest.TextTestRunner(stream=f, verbosity=19).run(
TestReportGenTestSuite(suite_fn), i)
f.close()
else:
with open('TestReportGen_result.txt', 'w', encoding='utf-8') as f:
for i in range(repeat):
unittest.TextTestRunner(stream=f, verbosity=19).run(
TestReportGenTestSuite(suite_fn), i)
f.close()
return 0
def execute(self, test, litConfig):
litConfig.ignoreStdErr = self.ignoreStdErr
return TestRunner.executeTclTest(test, litConfig)
json(data, test_path)
self.assertTrue(isfile(test_path))
def test_json_update(self):
'''
Tests that a JSON file gets updated.
'''
data = {}
test_path = './testing_json.json'
json(data, test_path)
updated_data = {'update_test': True}
json(updated_data, test_path, overwrite=False)
store = StoreAdapter(method='JSON')
d = store.load_json(test_path)
self.assertEqual(d, updated_data)
def tearDown(self):
try:
remove('./testing_json.json')
except:
pass
try:
remove('./testing_csv.csv')
except:
pass
TestRunner.main()
def executeOne(cmd):
return TestRunner.executeCommand(cmd + args, cwd)
