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)