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)