def setUp(self):
self.machine_v1 = Machine('Machine', info={'nb_cpus': 2})
self.run_v1 = Run(0.0, '1982-01-01 00:00:00', {'tag': 'nts',
'run_order': 18246})
self.tests_samples = [TestSamples('Test.exec', [1.7, 2.8],
{'nb_files': 2})]
self.report_v1 = Report(self.machine_v1, self.run_v1,
self.tests_samples)
self.machine_v2 = Machine('Machine', info={'nb_cpus': 2},
report_version=2)
self.run_v2 = Run(0.0, info={'llvm_project_revision': 18246},
report_version=2)
samples = MetricSamples('execution_time', [21.4, 3.2])
self.tests = [Test('Test', [samples], {'nb_files': 2})]
self.report_v2 = Report(self.machine_v2, self.run_v2, self.tests, 2)
def setUp(self):
self.machine = Machine('Machine', info={'nb_cpus': 2})
self.run = Run(0.0, '1982-01-01 00:00:00', {
'tag': 'nts',
'run_order': 18246
})
self.tests_samples = [
TestSamples('Test.exec', [1.7, 2.8], {'nb_files': 2})
]
self.report = Report(self.machine, self.run, self.tests_samples)
def setUp(self):
self.info_v1 = {'tag': 'nts', 'run_order': 18246}
self.run_float_start_v1 = Run(0.0, None, self.info_v1)
self.run_float_end_v1 = Run(None, 0.0, self.info_v1)
self.info_v2 = {'llvm_project_revision': 18246}
self.run_float_start_v2 = Run(0.0, info=self.info_v2, report_version=2)
self.run_float_end_v2 = Run(end_time=0.0, info=self.info_v2,
report_version=2)
def main():
from optparse import OptionParser
parser = OptionParser("usage: %prog [options] [output]")
opts, args = parser.parse_args()
if len(args) == 0:
output = '-'
elif len(args) == 1:
output = args[0]
else:
parser.error("invalid number of arguments")
if output == '-':
output = sys.stdout
else:
output = open(output, 'w')
offset = math.pi / 5
delay = 120.
machine = Machine('Mr. Sin Wave', info={'delay': delay})
start = time.time()
run = Run(start, start, info={'t': start, 'tag': 'simple', 'run_order': 1})
tests = [
TestSamples('simple.%s' % name,
[fn(start * 2 * math.pi / delay + j * offset)],
info={'offset': j}) for j in range(5)
for name, fn in (('sin', math.sin), ('cos', math.cos),
('random', lambda x: random.random()))
]
report = Report(machine, run, tests)
print >> output, report.render()
if output is not sys.stderr:
output.close()
def test_constructor(self):
info = {'__report_version__': '1', 'tag': 'nts', 'run_order': '18246'}
# Check time normalization of end time from float.
self.assertEqual(self.run_float_start.start_time,
'1970-01-01 00:00:00')
self.assertTrue(self.run_float_start.end_time)
self.assertNotEqual(self.run_float_start.end_time,
self.run_float_start.start_time)
self.assertTrue(
datetime.strptime(self.run_float_start.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(self.run_float_start.info, info)
# Check time normalization of end time from datetime.
run_str_start = Run('2019-07-01 01:02:03', None, info=self.info)
self.assertEqual(run_str_start.start_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_start.end_time)
self.assertNotEqual(run_str_start.end_time, run_str_start.start_time)
self.assertTrue(
datetime.strptime(run_str_start.end_time, '%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_start.info, info)
# Check time normalization of end time from string.
run_datetime_start = Run(datetime(2019, 7, 2), None, info=self.info)
self.assertEqual(run_datetime_start.start_time, '2019-07-02 00:00:00')
self.assertTrue(run_datetime_start.end_time)
self.assertNotEqual(run_datetime_start.end_time,
run_datetime_start.start_time)
self.assertTrue(
datetime.strptime(run_datetime_start.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_start.info, info)
# Check time normalization of start time from float.
run_float_end = Run(None, 0.0, self.info)
self.assertEqual(run_float_end.end_time, '1970-01-01 00:00:00')
self.assertTrue(run_float_end.start_time)
self.assertNotEqual(run_float_end.start_time, run_float_end.end_time)
self.assertTrue(
datetime.strptime(run_float_end.start_time, '%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_float_end.info, info)
# Check time normalization of start time from datetime.
run_str_end = Run(None, '2019-07-01 01:02:03', self.info)
self.assertEqual(run_str_end.end_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_end.start_time)
self.assertNotEqual(run_str_end.start_time, run_str_end.end_time)
self.assertTrue(
datetime.strptime(run_str_end.start_time, '%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_end.info, info)
# Check time normalization of start time from string.
run_datetime_end = Run(None, datetime(2019, 7, 2), self.info)
self.assertEqual(run_datetime_end.end_time, '2019-07-02 00:00:00')
self.assertTrue(run_datetime_end.start_time)
self.assertNotEqual(run_datetime_end.start_time,
run_datetime_end.end_time)
self.assertTrue(
datetime.strptime(run_datetime_end.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_end.info, info)
# Check failure when info contains __report_version__ key.
self.assertRaisesRegexp(ValueError, '__report_version__.*reserved',
Run, None, None, info)
def setUp(self):
self.info = {'tag': 'nts', 'run_order': 18246}
self.run_float_start = Run(0.0, None, self.info)
class TestRun(unittest.TestCase):
def setUp(self):
self.info = {'tag': 'nts', 'run_order': 18246}
self.run_float_start = Run(0.0, None, self.info)
def test_constructor(self):
info = {'__report_version__': '1', 'tag': 'nts', 'run_order': '18246'}
# Check time normalization of end time from float.
self.assertEqual(self.run_float_start.start_time,
'1970-01-01 00:00:00')
self.assertTrue(self.run_float_start.end_time)
self.assertNotEqual(self.run_float_start.end_time,
self.run_float_start.start_time)
self.assertTrue(
datetime.strptime(self.run_float_start.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(self.run_float_start.info, info)
# Check time normalization of end time from datetime.
run_str_start = Run('2019-07-01 01:02:03', None, info=self.info)
self.assertEqual(run_str_start.start_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_start.end_time)
self.assertNotEqual(run_str_start.end_time, run_str_start.start_time)
self.assertTrue(
datetime.strptime(run_str_start.end_time, '%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_start.info, info)
# Check time normalization of end time from string.
run_datetime_start = Run(datetime(2019, 7, 2), None, info=self.info)
self.assertEqual(run_datetime_start.start_time, '2019-07-02 00:00:00')
self.assertTrue(run_datetime_start.end_time)
self.assertNotEqual(run_datetime_start.end_time,
run_datetime_start.start_time)
self.assertTrue(
datetime.strptime(run_datetime_start.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_start.info, info)
# Check time normalization of start time from float.
run_float_end = Run(None, 0.0, self.info)
self.assertEqual(run_float_end.end_time, '1970-01-01 00:00:00')
self.assertTrue(run_float_end.start_time)
self.assertNotEqual(run_float_end.start_time, run_float_end.end_time)
self.assertTrue(
datetime.strptime(run_float_end.start_time, '%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_float_end.info, info)
# Check time normalization of start time from datetime.
run_str_end = Run(None, '2019-07-01 01:02:03', self.info)
self.assertEqual(run_str_end.end_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_end.start_time)
self.assertNotEqual(run_str_end.start_time, run_str_end.end_time)
self.assertTrue(
datetime.strptime(run_str_end.start_time, '%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_end.info, info)
# Check time normalization of start time from string.
run_datetime_end = Run(None, datetime(2019, 7, 2), self.info)
self.assertEqual(run_datetime_end.end_time, '2019-07-02 00:00:00')
self.assertTrue(run_datetime_end.start_time)
self.assertNotEqual(run_datetime_end.start_time,
run_datetime_end.end_time)
self.assertTrue(
datetime.strptime(run_datetime_end.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_end.info, info)
# Check failure when info contains __report_version__ key.
self.assertRaisesRegexp(ValueError, '__report_version__.*reserved',
Run, None, None, info)
def test_update(self):
# Check update with a supplied end time.
end_time_updated_run_float_start = copy.deepcopy(self.run_float_start)
end_time_updated_run_float_start.update_endtime(datetime(2019, 8, 2))
self.assertEqual(end_time_updated_run_float_start.end_time,
'2019-08-02 00:00:00')
# Check update with default (=now) end time.
updated_run_float_start = (
copy.deepcopy(end_time_updated_run_float_start))
updated_run_float_start.update_endtime()
self.assertTrue(updated_run_float_start.end_time)
self.assertNotEqual(updated_run_float_start.end_time,
updated_run_float_start.start_time)
self.assertNotEqual(updated_run_float_start.end_time,
end_time_updated_run_float_start.end_time)
def test_render(self):
d = {
'Start Time': '1970-01-01 00:00:00',
'End Time': self.run_float_start.end_time,
'Info': {
'__report_version__': '1',
'run_order': '18246',
'tag': 'nts'
}
}
self.assertDictEqual(self.run_float_start.render(), d)
def test_constructor(self):
info = {'__report_version__': '1',
'tag': 'nts',
'run_order': '18246'}
# Check time normalization of end time from float.
self.assertEqual(self.run_float_start_v1.start_time,
'1970-01-01 00:00:00')
self.assertTrue(self.run_float_start_v1.end_time)
self.assertNotEqual(self.run_float_start_v1.end_time,
self.run_float_start_v1.start_time)
self.assertTrue(datetime.strptime(self.run_float_start_v1.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(self.run_float_start_v1.info, info)
self.assertEqual(self.run_float_start_v1.report_version, 1)
# Check time normalization of end time from datetime.
run_str_start_v1 = Run('2019-07-01 01:02:03', None, info=self.info_v1)
self.assertEqual(run_str_start_v1.start_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_start_v1.end_time)
self.assertNotEqual(run_str_start_v1.end_time,
run_str_start_v1.start_time)
self.assertTrue(datetime.strptime(run_str_start_v1.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_start_v1.info, info)
self.assertEqual(run_str_start_v1.report_version, 1)
# Check time normalization of end time from string.
run_datetime_start_v1 = Run(datetime(2019, 7, 2), None,
info=self.info_v1)
self.assertEqual(run_datetime_start_v1.start_time,
'2019-07-02 00:00:00')
self.assertTrue(run_datetime_start_v1.end_time)
self.assertNotEqual(run_datetime_start_v1.end_time,
run_datetime_start_v1.start_time)
self.assertTrue(datetime.strptime(run_datetime_start_v1.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_start_v1.info, info)
self.assertEqual(run_datetime_start_v1.report_version, 1)
# Check time normalization of start time from float.
run_float_end_v1 = Run(None, 0.0, self.info_v1)
self.assertEqual(run_float_end_v1.end_time, '1970-01-01 00:00:00')
self.assertTrue(run_float_end_v1.start_time)
self.assertNotEqual(run_float_end_v1.start_time,
run_float_end_v1.end_time)
self.assertTrue(datetime.strptime(run_float_end_v1.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_float_end_v1.info, info)
self.assertEqual(run_float_end_v1.report_version, 1)
# Check time normalization of start time from datetime.
run_str_end_v1 = Run(None, '2019-07-01 01:02:03', self.info_v1)
self.assertEqual(run_str_end_v1.end_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_end_v1.start_time)
self.assertNotEqual(run_str_end_v1.start_time, run_str_end_v1.end_time)
self.assertTrue(datetime.strptime(run_str_end_v1.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_end_v1.info, info)
self.assertEqual(run_str_end_v1.report_version, 1)
# Check time normalization of start time from string.
run_datetime_end_v1 = Run(None, datetime(2019, 7, 2), self.info_v1)
self.assertEqual(run_datetime_end_v1.end_time, '2019-07-02 00:00:00')
self.assertTrue(run_datetime_end_v1.start_time)
self.assertNotEqual(run_datetime_end_v1.start_time,
run_datetime_end_v1.end_time)
self.assertTrue(datetime.strptime(run_datetime_end_v1.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_end_v1.info, info)
self.assertEqual(run_datetime_end_v1.report_version, 1)
# Check failure when info contains __report_version__ key.
self.assertRaisesRegexp(ValueError, '__report_version__.*reserved',
Run, None, None, info)
# Check missing tag entry in info for format version 1.
self.assertRaisesRegexp(ValueError,
"Missing 'tag' entry in 'info' dictionary",
Run, info={'run_order': 40385})
# Check missing run_order entry in info for format version 1.
self.assertRaisesRegexp(ValueError,
"Missing 'run_order' entry in 'info'"
" dictionary", Run, info={'tag': 'nts'})
# Test empty start and end time in format version 2
self.assertEqual(self.run_float_start_v2.start_time,
'1970-01-01 00:00:00')
self.assertIsNone(self.run_float_start_v2.end_time)
self.assertDictEqual(self.run_float_start_v2.info,
{'llvm_project_revision': '18246'})
self.assertEqual(self.run_float_start_v2.report_version, 2)
# Check missing llvm_project_revision entry in info for format
# version 2.
self.assertRaisesRegexp(ValueError,
"Missing 'llvm_project_revision' entry in"
" 'info' dictionary", Run, 0.0, info={},
report_version=2)
# Check call to check()
self.assertRaises(AssertionError, Run, info=self.info_v2,
report_version=3)
class TestRun(unittest.TestCase):
def setUp(self):
self.info_v1 = {'tag': 'nts', 'run_order': 18246}
self.run_float_start_v1 = Run(0.0, None, self.info_v1)
self.run_float_end_v1 = Run(None, 0.0, self.info_v1)
self.info_v2 = {'llvm_project_revision': 18246}
self.run_float_start_v2 = Run(0.0, info=self.info_v2, report_version=2)
self.run_float_end_v2 = Run(end_time=0.0, info=self.info_v2,
report_version=2)
def test_constructor(self):
info = {'__report_version__': '1',
'tag': 'nts',
'run_order': '18246'}
# Check time normalization of end time from float.
self.assertEqual(self.run_float_start_v1.start_time,
'1970-01-01 00:00:00')
self.assertTrue(self.run_float_start_v1.end_time)
self.assertNotEqual(self.run_float_start_v1.end_time,
self.run_float_start_v1.start_time)
self.assertTrue(datetime.strptime(self.run_float_start_v1.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(self.run_float_start_v1.info, info)
self.assertEqual(self.run_float_start_v1.report_version, 1)
# Check time normalization of end time from datetime.
run_str_start_v1 = Run('2019-07-01 01:02:03', None, info=self.info_v1)
self.assertEqual(run_str_start_v1.start_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_start_v1.end_time)
self.assertNotEqual(run_str_start_v1.end_time,
run_str_start_v1.start_time)
self.assertTrue(datetime.strptime(run_str_start_v1.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_start_v1.info, info)
self.assertEqual(run_str_start_v1.report_version, 1)
# Check time normalization of end time from string.
run_datetime_start_v1 = Run(datetime(2019, 7, 2), None,
info=self.info_v1)
self.assertEqual(run_datetime_start_v1.start_time,
'2019-07-02 00:00:00')
self.assertTrue(run_datetime_start_v1.end_time)
self.assertNotEqual(run_datetime_start_v1.end_time,
run_datetime_start_v1.start_time)
self.assertTrue(datetime.strptime(run_datetime_start_v1.end_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_start_v1.info, info)
self.assertEqual(run_datetime_start_v1.report_version, 1)
# Check time normalization of start time from float.
run_float_end_v1 = Run(None, 0.0, self.info_v1)
self.assertEqual(run_float_end_v1.end_time, '1970-01-01 00:00:00')
self.assertTrue(run_float_end_v1.start_time)
self.assertNotEqual(run_float_end_v1.start_time,
run_float_end_v1.end_time)
self.assertTrue(datetime.strptime(run_float_end_v1.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_float_end_v1.info, info)
self.assertEqual(run_float_end_v1.report_version, 1)
# Check time normalization of start time from datetime.
run_str_end_v1 = Run(None, '2019-07-01 01:02:03', self.info_v1)
self.assertEqual(run_str_end_v1.end_time, '2019-07-01 01:02:03')
self.assertTrue(run_str_end_v1.start_time)
self.assertNotEqual(run_str_end_v1.start_time, run_str_end_v1.end_time)
self.assertTrue(datetime.strptime(run_str_end_v1.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_str_end_v1.info, info)
self.assertEqual(run_str_end_v1.report_version, 1)
# Check time normalization of start time from string.
run_datetime_end_v1 = Run(None, datetime(2019, 7, 2), self.info_v1)
self.assertEqual(run_datetime_end_v1.end_time, '2019-07-02 00:00:00')
self.assertTrue(run_datetime_end_v1.start_time)
self.assertNotEqual(run_datetime_end_v1.start_time,
run_datetime_end_v1.end_time)
self.assertTrue(datetime.strptime(run_datetime_end_v1.start_time,
'%Y-%m-%d %H:%M:%S'))
self.assertDictEqual(run_datetime_end_v1.info, info)
self.assertEqual(run_datetime_end_v1.report_version, 1)
# Check failure when info contains __report_version__ key.
self.assertRaisesRegexp(ValueError, '__report_version__.*reserved',
Run, None, None, info)
# Check missing tag entry in info for format version 1.
self.assertRaisesRegexp(ValueError,
"Missing 'tag' entry in 'info' dictionary",
Run, info={'run_order': 40385})
# Check missing run_order entry in info for format version 1.
self.assertRaisesRegexp(ValueError,
"Missing 'run_order' entry in 'info'"
" dictionary", Run, info={'tag': 'nts'})
# Test empty start and end time in format version 2
self.assertEqual(self.run_float_start_v2.start_time,
'1970-01-01 00:00:00')
self.assertIsNone(self.run_float_start_v2.end_time)
self.assertDictEqual(self.run_float_start_v2.info,
{'llvm_project_revision': '18246'})
self.assertEqual(self.run_float_start_v2.report_version, 2)
# Check missing llvm_project_revision entry in info for format
# version 2.
self.assertRaisesRegexp(ValueError,
"Missing 'llvm_project_revision' entry in"
" 'info' dictionary", Run, 0.0, info={},
report_version=2)
# Check call to check()
self.assertRaises(AssertionError, Run, info=self.info_v2,
report_version=3)
def test_check(self):
# Check valid v1 instance.
self.run_float_start_v1.check()
# Check too big version.
self.run_float_start_v2.report_version = 3
self.assertRaises(AssertionError, self.run_float_start_v2.check)
# Check valid v2 instance.
self.run_float_start_v2.report_version = 2
self.run_float_start_v2.start_time = None
self.run_float_start_v2.check()
# Check no time or info.
self.run_float_start_v2.info = {}
self.assertRaisesRegexp(ValueError, 'No data defined in this Run',
self.run_float_start_v2.check)
def test_update(self):
# Check update with a supplied end time.
end_time_updated_run_float_start_v1 = (
copy.deepcopy(self.run_float_start_v1))
end_time_updated_run_float_start_v1.update_endtime(
datetime(2019, 8, 2))
self.assertEqual(end_time_updated_run_float_start_v1.end_time,
'2019-08-02 00:00:00')
# Check update with default end time in format v1: end time =
# now.
updated_run_float_start_v1 = (
copy.deepcopy(end_time_updated_run_float_start_v1))
updated_run_float_start_v1.update_endtime()
self.assertTrue(updated_run_float_start_v1.end_time)
self.assertNotEqual(updated_run_float_start_v1.end_time,
updated_run_float_start_v1.start_time)
self.assertNotEqual(updated_run_float_start_v1.end_time,
end_time_updated_run_float_start_v1.end_time)
# Check update with default end time in format v2: end time =
# None.
updated_run_float_end_v2 = copy.deepcopy(self.run_float_end_v2)
updated_run_float_end_v2.update_endtime()
self.assertEqual(updated_run_float_end_v2.start_time,
updated_run_float_end_v2.start_time)
self.assertIsNone(updated_run_float_end_v2.end_time)
def test_render(self):
# Check rendering of format v1.
d1 = {'Start Time': '1970-01-01 00:00:00',
'End Time': self.run_float_start_v1.end_time,
'Info': {'__report_version__': '1',
'run_order': '18246',
'tag': 'nts'}}
self.assertDictEqual(self.run_float_start_v1.render(), d1)
# Check rendering of format v2 with no end time.
d2 = {'start_time': '1970-01-01 00:00:00',
'llvm_project_revision': '18246'}
self.assertDictEqual(self.run_float_start_v2.render(), d2)
# Check rendering of format v2 with no start time.
d3 = {'end_time': '1970-01-01 00:00:00',
'llvm_project_revision': '18246'}
self.assertDictEqual(self.run_float_end_v2.render(), d3)