def __init__(self):
TestSuite.__init__(self, "publish/subscribe")
i = 1
for test in PubSub.tests:
(subtopic, pubtopic) = test[0:2]
match = test[2] if len(test) >= 3 else True
def _funcbuilder(subtopic, pubtopic, match):
def _test(self):
debug("pubtopic={0}, subtopic={1}".format(pubtopic,subtopic))
ret = self._pubsub(pubtopic, subtopic, match)
return ret if match else not ret
return _test
setattr(self,
"test_{0:03}".format(i),
types.MethodType(
catch(
desc("{0} {1} {2}".format(subtopic, "MATCH" if match else "DON'T MATCH", pubtopic))(
_funcbuilder(subtopic, pubtopic, match)
)),
self
)
)
i += 1
def doRunAllTests(argument):
from TestSuite import TestSuite
suite = TestSuite()
(total, ok, fail) = suite.runAll()
gt.system.printEventAndResult("OK", ok)
gt.system.printEventAndResult("Fail", fail)
sys.exit(0)
def testSetUpErrorsReport(self):
suite = TestSuite()
suite.add(WasRun("testMethod"))
suite.add(SetUpError("testMethod", ZeroDivisionError))
suite.add(SetUpError("testBrokenMethod", ValueError))
suite.run(self.result)
assert "3 run, 2 failed, SetUpError.testMethod-ZeroDivisionError, SetUpError.testBrokenMethod-ValueError" == \
self.result.summary()
def get_suite(self, instance):
suite = TestSuite()
result = TestSuite()
total_inst = instance.data['total']
target = self.get_target(instance.data)
[target.append(None) for x in range(0, total_inst - len(target))]
suite = self.split(target, total_inst)
result = result.nest(total_inst * [[None]], suite, total_inst)
return result
def testSuite(self):
suite = TestSuite()
suite.add(WasRun("testMethod"))
suite.add(WasRun("testBrokenMethod"))
suite.run(self.result)
assert "2 run, 1 failed, WasRun.testBrokenMethod-Exception" == self.result.summary(
)
def split(self, target, total):
x = len(target) / total
bigger = len(target) % total
suite = TestSuite()
[
suite.append(target[i * (x + 1):(i + 1) * (x + 1)])
for i in range(bigger)
]
[
suite.append(target[(bigger * (x + 1)) + i * x:(bigger * (x + 1)) +
(i + 1) * x]) for i in range(total - bigger)
]
random.shuffle(suite)
return suite
def testSuite(self):
suite = TestSuite()
suite.add(WasRun("testMethod"))
suite.add(WasRun("testBrokenMethod"))
suite.run(self.result)
assert ("2 run, 1 failed" == result.summary())
def testTestSuite(self):
suite = TestSuite()
suite.add(WasRun("testMethod"))
suite.add(WasRun("testBrokenMethod"))
result = TestResult()
suite.run(result)
print "???"
assert result.summary() == "2 run, 1 failed"
def get_suite(self, instance):
versions = self.get_versions(instance.data)
tests = self.get_tests(instance.data)
result = TestSuite(content='random')
tuples = []
for v in versions:
[tuples.append([v, t]) for t in tests]
random.shuffle(tuples)
total_inst = instance.data['total']
result = self.split(tuples, total_inst)
suite = TestSuite(content='random')
for element in result:
v = []
t = []
[v.append(item[0]) for item in element]
[t.append(item[1]) for item in element]
suite.append([v, t])
return suite
def __init__(self, options, args):
self.TestSuite = False # used by pmt nruns logic
self.module = dict() # dict of modules keyed by name
self.mp = dict() # dict of model programs keyed by same module name
# Populate self.module and self.mp from modules named in command line args
# Models that users write are just modules, not classes (types)
# so we find out what type to wrap each one in
# by checking for one of each type's required attributes using hasattr
for mname in args: # args is list of module name
self.module[mname] = __import__(mname)
if hasattr(self.module[mname], 'graph'):
self.mp[mname] = FSM(self.module[mname], options.exclude,
options.action)
# for backwards compatibility we accept all of these test_suite variants
elif (hasattr(self.module[mname], 'testSuite')
or hasattr(self.module[mname], 'testsuite')
or hasattr(self.module[mname], 'test_suite')):
self.mp[mname] = TestSuite(self.module[mname], options.exclude,
options.action)
self.TestSuite = True # used by pmt nruns logic
elif self.module[mname].__doc__.strip().upper().startswith(
'PYMODEL CONFIG'):
pass # configuration module, merely importing it did all the work
else:
# got this far, should be a ModelProgram -- if not, crash
self.mp[mname] = ModelProgram(self.module[mname],
options.exclude, options.action)
# Now that all modules have been imported and executed their __init__
# do a postprocessing pass over all model objects
# to process metadata that might be affected by configuration modules
for mp in self.mp.values():
mp.post_init()
# set of all anames in all model programs - the vocabulary of the product
self.anames = set().union(
*
[set([a.__name__ for a in mp.actions]) for mp in self.mp.values()])
# print 'anames %s' % self.anames # DEBUG
# set of anames of all observable actions in all model programs
# observables obtain arg values from the environment, not parameter gen.
self.observables = set().union(*[
set([a.__name__ for a in mp.module.observables])
for mp in self.mp.values()
])
# FSM and TestSuite must have .observables
# print 'observables %s' % self.observables # DEBUG
# dict from aname to set of all m where aname is in vocabulary
self.vocabularies = \
dict([(aname, set([m for m in self.mp if aname in
[a.__name__ for a in self.mp[m].actions]]))
for aname in self.anames])
def __init__(self):
TestSuite.__init__(self, "basic tests")
assert("1 run, 1 failed" == self.result.summary())
def testFailedResult(self):
test = WasRun("testBrokenMethod")
test.run(self.result)
assert("1 run, 1 failed" == self.result.summary())
def testSuite(self):
suite = TestSuite()
suite.add(WasRun("testMethod"))
suite.add(WasRun("testBrokenMethod"))
suite.run(self.result)
assert("2 run, 1 failed" == self.result.summary())
if __name__ == "__main__":
testMethods = [ "testTemplateMethod",
"testResult",
"testFailedResultFormatting",
"testFailedResult",
"testSuite"
];
suite = TestSuite()
for method in testMethods:
case = TestCaseTest(method)
suite.add(case)
result = TestResult()
suite.run(result)
print("{} : {}".format(method, result.summary()))
def __init__(self):
TestSuite.__init__(self, "basic tests")
def __init__(self):
TestSuite.__init__(self)
from TestCaseTest import TestCaseTest
from TestResult import TestResult
from TestSuite import TestSuite
suite = TestSuite()
suite.add(TestCaseTest("test_template_method"))
suite.add(TestCaseTest("test_result"))
suite.add(TestCaseTest("test_failed_result"))
suite.add(TestCaseTest("test_failed_result_formatting"))
result = TestResult()
suite.run(result)
print(result.summary())
def testSuite(sefl):
suite = TestSuite()
suite.add(WasRun('testMethod'))
suite.add(WasRun('testBrokenMethod'))
suite.run(self.result)
assert('2 run, 1 failed' == self.result.summary())
def testSuite(self):
suite = TestSuite()
suite.add(WasRun("testMethod"))
suite.add(WasRun("testBrokenMethod"))
suite.run(self.result)
assert("2 run, 1 failed" == self.result.summary())
def testSuiteFromCases(self):
test = WasRun("testMethod")
suite = TestSuite.fromTestCase(test)
assert(len(suite.tests) == 1)
suite.run(self.result)
assert("1 run, 0 failed" == self.result.summary())
def __init__(self):
TestSuite.__init__(self, "SSL2")
def __init__(self):
TestSuite.__init__(self, "SSL")
def test_suite(self):
suite = TestSuite()
suite.add(WasRun("test_method"))
suite.add(WasRun("test_broken_method"))
suite.run(self.result)
assert "2 run, 1 failed" == self.result.summary()
def test_suite(self):
suite = TestSuite()
suite.add(WasRun('test_method'))
suite.run(self.result)
assert ("2 run, 1 failed" == self.result.summary())
def __init__(self):
TestSuite.__init__(self, "error cases")
def __init__(self):
TestSuite.__init__(self, "unicode")
# if it's a test suite config, get a new test suite object
if re.match(r'^TH_SUITE$',pair[0]) :
dprint(3," * Found suite " + pair[1])
# suites can have attributes - they are separated by ::
# Ex: TH_SUITE = foo::timeout=45::attr2=val2
# NOTE: buildbot will currently timeout the entire testharness if any test suite lasts
# more than 30 minutes. If we ever have a suite that needs more than 30 minutes, we
# need testharness to print to stdout every once in a while.
# separate the TH_SUITE value portion by the :: string
items = re.split(r'::',pair[1])
# first item in the list must be the name of the suite
suite = TestSuite(items[0].strip())
dprint(3," * name = " + suite.name)
test_run.test_suite_list.append(suite)
# go through the rest of the attributes (if any)
attr_count=1
while attr_count < len(items) :
# split the attribute on the first '='
attr = re.split(r'=',items[attr_count],1)
attr_count+=1
# strip the white space from the key/value pairs
for i in range(0,2) :
attr[i] = attr[i].strip()
# end for
def __init__(self):
TestSuite.__init__(self, "system events")
def __init__(self):
TestSuite.__init__(self, "qos 1 delivery")
def main():
tests = TestSuite()
tests.performGenerationsTest()
tests = TestSuite()
tests.performSubPopulationsTest()
tests = TestSuite()
tests.performPopulationsTest()
tests = TestSuite()
tests.performCrossingTest()
tests = TestSuite()
tests.performMutationTest()
tests = TestSuite()
tests.performRayTest()
tests = TestSuite()
tests.plotFunction()
def testExceptionInSetup(self):
test = BadSetup("testMethod")
test.run(self.result)
assert("1 run, 1 failed" == self.result.summary())
def testSuite(self):
suite = TestSuite.emptySuite()
suite.add(WasRun("testMethod"))
suite.add(WasRun("testBrokenMethod"))
suite.run(self.result)
assert("2 run, 1 failed" == self.result.summary())
def testSuiteFromCases(self):
test = WasRun("testMethod")
suite = TestSuite.fromTestCase(test)
assert(len(suite.tests) == 1)
suite.run(self.result)
assert("1 run, 0 failed" == self.result.summary())
suite = TestSuite.emptySuite()
suite.add(TestCaseTest("testTemplateMethod"))
suite.add(TestCaseTest("testResult"))
suite.add(TestCaseTest("testSuiteFromCases"))
suite.add(TestCaseTest("testSuite"))
suite.add(TestCaseTest("testFailedResult"))
suite.add(TestCaseTest("testFailedResultFormatting"))
suite.add(TestCaseTest("testExceptionInSetup"))
result = TestResult()
suite.run(result)
print result.summary()
from TestCaseTest import TestCaseTest as TestCaseTest
from TestSuite import TestSuite as TestSuite
from TestResult import TestResult as TestResult
suite = TestSuite()
suite.add(TestCaseTest('testTemplateMethod'))
suite.add(TestCaseTest('testResult'))
suite.add(TestCaseTest('testFailedResultFormatting'))
suite.add(TestCaseTest('testSuite'))
result = TestResult()
suite.run(result)
print(result.summary())
from TestCaseTest import TestCaseTest
from TestResult import TestResult
from TestSuite import TestSuite
suite = TestSuite()
suite.add(TestCaseTest("testTemplateMethod"))
suite.add(TestCaseTest("testResult"))
suite.add(TestCaseTest("testFailedResult"))
suite.add(TestCaseTest("testFailedResultFormatting"))
suite.add(TestCaseTest("testSuite"))
result = TestResult()
suite.run(result)
print result.summary()
def __init__(self):
"build a test suite for spec jvm 98"
TestSuite.__init__(self, self.SPECLIST)
test.run(self.result)
assert "1 run, 1 failed" == self.result.summary()
def test_failed_result_formatting(self):
self.result.test_started()
self.result.test_failed()
assert "1 run, 1 failed" == self.result.summary()
def test_failed_setup_result(self):
test = SetupFails("test_method")
test.run(self.result)
assert "1 run, 1 failed" == self.result.summary()
def test_failed_method_runs_teardown(self):
test = TestMethodFails("test_method")
test.run(self.result)
assert test.tear_down_ran is True
suite = TestSuite()
suite.add(TestCaseTest("test_template_method"))
suite.add(TestCaseTest("test_result"))
suite.add(TestCaseTest("test_failed_result_formatting"))
suite.add(TestCaseTest("test_failed_result"))
suite.add(TestCaseTest("test_failed_setup_result"))
suite.add(TestCaseTest("test_failed_method_runs_teardown"))
suiteResult = TestResult()
suite.run(suiteResult)
print(suiteResult.summary())
# if it's a test suite config, get a new test suite object
if re.match(r'^TH_SUITE$', pair[0]):
dprint(3, " * Found suite " + pair[1])
# suites can have attributes - they are separated by ::
# Ex: TH_SUITE = foo::timeout=45::attr2=val2
# NOTE: buildbot will currently timeout the entire testharness if any test suite lasts
# more than 30 minutes. If we ever have a suite that needs more than 30 minutes, we
# need testharness to print to stdout every once in a while.
# separate the TH_SUITE value portion by the :: string
items = re.split(r'::', pair[1])
# first item in the list must be the name of the suite
suite = TestSuite(items[0].strip())
dprint(3, " * name = " + suite.name)
test_run.test_suite_list.append(suite)
# go through the rest of the attributes (if any)
attr_count = 1
while attr_count < len(items):
# split the attribute on the first '='
attr = re.split(r'=', items[attr_count], 1)
attr_count += 1
# strip the white space from the key/value pairs
for i in range(0, 2):
attr[i] = attr[i].strip()
# end for
def create_xml_file_report(self):
# extract testcase information from Jshu xml suite
_ts_object = TestSuite(self._input_jshu_xml_file)
_ts_object.extract_testcase_list_from_xml()
_tc_list = _ts_object.get_testcase_list()
#get suite start time and end time
_suite_starttime = _tc_list[0]._start_time
_suite_endtime = _tc_list[-1]._end_time
# inital xml root of RobotFramework output.xml
root = ET.Element("robot", generator="Robot Framwork", generated="")
suite = ET.SubElement(root,
"suite",
id="RobotFramework Output XML",
name=self._job_name,
source="Something")
for _tc in _tc_list:
test = ET.SubElement(suite, "test", id=_tc._name, name=_tc._name)
kw = ET.SubElement(test,
"kw",
name="LOG FROM JSHU",
library="BuiltIn")
doc = ET.SubElement(
kw,
"doc").text = "Logs the given message with the given level."
msg = ET.SubElement(kw,
"msg",
timestamp="20171017 14:49:30.312",
level="INFO").text = _tc._log
kw_status = ET.SubElement(kw,
"status",
status=_tc._status,
starttime=_tc._start_time,
endtime=_tc._end_time)
test_status = ET.SubElement(test,
"status",
status=_tc._status,
starttime=_tc._start_time,
endtime=_tc._end_time,
critical="yes")
suite_status = ET.SubElement(suite,
"status",
status=_tc._status,
starttime=_suite_starttime,
endtime=_suite_endtime)
statistics = ET.SubElement(root, "statistics")
total = ET.SubElement(statistics, "total")
# ET.SubElement(total, "stat", passed= "1",failed = "0").text = "some value1"
# ET.SubElement(total, "stat", passed= "1",failed = "0").text = "some vlaue2"
tag = ET.SubElement(statistics, "tag")
suite = ET.SubElement(statistics, "suite")
ET.SubElement(suite, "stat", passed="1",
failed="0").text = "some value1"
statistics = ET.SubElement(root, "errors")
#writing xml tree to file
file_name = "newXML/Final.xml"
tree = ET.ElementTree(root)
tree.write(file_name, xml_declaration=True)
import System
from time import sleep
@TestSuite.test
def TestAdd():
sleep(10)
assert (System.add(1, 2) == 3)
assert (System.add(0, 0) == 0)
assert (System.add(-1000, 900) == -100)
@TestSuite.test
def TestSubtract():
assert (System.subtract(4, 5) == -1)
assert (System.subtract(2, 1) == 1)
assert (System.subtract(-1000, -1000) == 0)
@TestSuite.test
def TestFail():
sleep(5)
assert (1 == 2)
print(*TestSuite.getTests(), sep="\n")
TestSuite.run()
print(*TestSuite.getTests(), sep="\n")
def main():
suite = TestSuite()
suite.add(TestCaseTest("test_template_method"))
suite.add(TestCaseTest("test_result"))
suite.add(TestCaseTest("test_failed_result"))
suite.add(TestCaseTest("test_failed_result_formatting"))
suite.add(TestCaseTest("test_suite"))
result = TestResult()
suite.run(result)
print(result.summary())
def __init__(self):
TestSuite.__init__(self, "qos 2 delivery")
def testSuite(self):
suite = TestSuite()
suite.add(TestCaseTest("testFailedResultFormatting"))
suite.add(TestCaseTest("setUp"))
suite.add(TestCaseTest("testTemplateMethod"))
suite.add(WasRun("testMethod"))
suite.add(TestCaseTest("testResult"))
suite.add(WasRun("testBrokenMethod"))
suite.add(TestCaseTest("testSetUpException"))
suite.run(self.result)
assert "6 run, 2 failed" == self.result.summary()
from TestCaseTest import TestCaseTest
from TestResult import TestResult
from TestSuite import TestSuite
suite = TestSuite()
suite.add(TestCaseTest("testTemplateMethod"))
suite.add(TestCaseTest("testResult"))
suite.add(TestCaseTest("testFailedResultFormatting"))
suite.add(TestCaseTest("testFailedResult"))
suite.add(TestCaseTest("testSuite"))
result = TestResult()
suite.run(result)
print(result.summary())
def __init__(self):
TestSuite.__init__(self, "CONNECT flags")
def test_failed_result_formatting(self):
self.result.test_started()
self.result.test_failed()
assert ("1 run, 1 failed" == self.result.summary())
def test_if_tear_down_runs_regardless(self):
self.test = WasRun("test_broken_method")
self.test.run(self.result)
assert ("setup tear_down " == self.test.log)
def test_suite(self):
suite = TestSuite()
suite.add(WasRun("test_method"))
suite.add(WasRun("test_broken_method"))
suite.run(self.result)
assert ("2 run, 1 failed" == self.result.summary())
if __name__ == "__main__":
suite = TestSuite()
suite.add(TestCaseTest("test_template_method"))
suite.add(TestCaseTest("test_result"))
suite.add(TestCaseTest("test_failed_result"))
suite.add(TestCaseTest("test_failed_result_formatting"))
suite.add(TestCaseTest("test_if_tear_down_runs_regardless"))
suite.add(TestCaseTest("test_suite"))
result = TestResult()
suite.run(result)
print(result.summary())
def ParseFileType(self, file_name, file_type):
Log.Log(Log.DEBUG, "Parsing " + file_type + " file: ")
print(str(file_name))
ret = ERROR
ts = None
tc = None
suite_regexp = None
case_regexp_list = None
if file_type == TestGlobal.GTEST_TYPE:
suite_regexp = GTEST_SUITE_REGEXP
case_regexp_list = GTEST_CASE_REGEXP_LIST
elif file_type == TestGlobal.JUNIT_TYPE:
suite_regexp = JUNIT_SUITE_REGEXP
case_regexp_list = JUNIT_CASE_REGEXP_LIST
elif file_type == TestGlobal.CUNIT_TYPE:
suite_regexp = CUNIT_SUITE_REGEXP
case_regexp_list = CUNIT_CASE_REGEXP_LIST
# TODO Implement other framework
else:
Log.Log(Log.ERROR, "Unknown file type in ParseFileType!")
return ERROR
f = open(file_name)
content = f.read()
f.close()
# Parsing Suite description
for m in re.finditer(suite_regexp, content, re.MULTILINE|re.DOTALL):
if m != None and ts == None:
ts = TestSuite()
# Log.Log(Log.DEBUG, "Suite: " + TestGlobal.StripCommentStars(m.group(1)))
ret = ts.ParseHeader(TestGlobal.StripCommentStars(m.group(1)))
if ret != OK:
break
# Verify
suite_name = os.path.basename(file_name).split('.')[0]
if ts.suite != suite_name:
Log.Log(Log.WARNING, "Some suite comment inconsistencies are detected in " + os.path.basename(file_name) + ": " + ts.suite + " != " + suite_name)
else:
ret = ERROR
break
if ret != OK:
Log.Log(Log.ERROR, "Invalid suite format in " + os.path.basename(file_name))
return ret
ts.type = file_type
ts.test_case_dict = dict()
# Parsing Case descriptions
ret = ERROR
for case_regexp in case_regexp_list:
for m in re.finditer(case_regexp, content, re.MULTILINE|re.DOTALL):
if m != None:
tc = TestCase()
tc.suite = ts # Add a backward link to the suite as well
tc.case = m.group(2)
# Log.Log(Log.DEBUG, "Case: " + TestGlobal.StripCommentStars(m.group(1)))
ret = tc.ParseHeader(TestGlobal.StripCommentStars(m.group(1)))
if ret == OK:
# Add tc into ts
if tc.case in ts.test_case_dict:
Log.Log(Log.WARNING, "Test case " + tc.case + " duplicated in " + ts.suite + ". Test case ignored!")
else:
ts.test_case_dict[tc.case] = tc
else:
Log.Log(Log.WARNING, "Impossible to parse header: " + m.group(1))
ret = OK # Just continue
else:
Log.Log(Log.WARNING, "No test cases in test suite!")
ret = ERROR
break
# Add ts to class dictionary
if not self.test_suite_dict:
self.test_suite_dict = dict()
if ts.suite in self.test_suite_dict:
Log.Log(Log.WARNING, "Test suite " + ts.suite + " duplicated. Test case ignored!")
else:
self.test_suite_dict[ts.suite] = ts
if ret == OK:
print("OK")
else:
print("ERROR")
return ret
