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)
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)