| # RUN: python %s |
| |
| import unittest |
| import logging |
| import copy |
| import re |
| import sys |
| from datetime import datetime |
| from lnt.testing import MetricSamples, Test, TestSamples, Run, Machine, Report |
| |
| logging.basicConfig(level=logging.DEBUG) |
| |
| |
| class MetricSamplesTest(unittest.TestCase): |
| def setUp(self): |
| self.samples_list_float = MetricSamples('execution_time', [21.4, 3.2]) |
| |
| def test_constructor(self): |
| # Check implicit float conversion from string. |
| samples_list_float_str = MetricSamples('execution_time', |
| ['6.7', '30.4']) |
| self.assertEqual(samples_list_float_str.metric, 'execution_time') |
| self.assertListEqual(samples_list_float_str.data, [6.7, 30.4]) |
| self.assertEqual(samples_list_float_str.report_version, 2) |
| |
| # Check explicit float conversion. |
| float_samples_list_float_str = MetricSamples('execution_time', |
| ['4.7', '32.4'], float) |
| self.assertEqual(float_samples_list_float_str.metric, 'execution_time') |
| self.assertListEqual(float_samples_list_float_str.data, [4.7, 32.4]) |
| self.assertEqual(float_samples_list_float_str.report_version, 2) |
| |
| # Check nop implicit float conversion from float. |
| self.assertEqual(self.samples_list_float.metric, 'execution_time') |
| self.assertListEqual(self.samples_list_float.data, [21.4, 3.2]) |
| self.assertEqual(self.samples_list_float.report_version, 2) |
| |
| # Check implicit float conversion from integer. |
| samples_list_int = MetricSamples('execution_time', [6, 11]) |
| self.assertEqual(samples_list_int.metric, 'execution_time') |
| self.assertIsInstance(samples_list_int.data[0], float) |
| self.assertIsInstance(samples_list_int.data[1], float) |
| self.assertListEqual(samples_list_int.data, [6.0, 11.0]) |
| self.assertEqual(samples_list_int.report_version, 2) |
| |
| # Check non-float conversion from float. |
| int_samples_list_float = MetricSamples('execution_time', [21.4, 3.2], |
| int) |
| self.assertEqual(int_samples_list_float.metric, 'execution_time') |
| self.assertIsInstance(int_samples_list_float.data[0], int) |
| self.assertIsInstance(int_samples_list_float.data[1], int) |
| self.assertListEqual(int_samples_list_float.data, [21, 3]) |
| self.assertEqual(int_samples_list_float.report_version, 2) |
| |
| # Check non-float conversion from same input type. |
| int_samples_list_int = MetricSamples('execution_time', [6, 11], int) |
| self.assertEqual(int_samples_list_int.metric, 'execution_time') |
| self.assertIsInstance(int_samples_list_int.data[0], int) |
| self.assertIsInstance(int_samples_list_int.data[1], int) |
| self.assertListEqual(int_samples_list_int.data, [6, 11]) |
| self.assertEqual(int_samples_list_int.report_version, 2) |
| |
| # Check explicit version. |
| samples_list_float_version = MetricSamples('execution_time', |
| [22.4, 5.2], |
| report_version=2) |
| self.assertEqual(samples_list_float_version.metric, 'execution_time') |
| self.assertListEqual(samples_list_float_version.data, [22.4, 5.2]) |
| self.assertEqual(samples_list_float_version.report_version, 2) |
| |
| # Check call to check(). |
| self.assertRaises(AssertionError, MetricSamples, 'execution_time', |
| [22.4, 5.2], report_version=1) |
| |
| def test_check(self): |
| # Check valid instance. |
| self.samples_list_float.report_version = 2 |
| self.samples_list_float.check() |
| |
| # Check too small version. |
| self.samples_list_float.report_version = 1 |
| self.assertRaises(AssertionError, self.samples_list_float.check) |
| |
| # Check too big version. |
| self.samples_list_float.report_version = 3 |
| self.assertRaises(AssertionError, self.samples_list_float.check) |
| |
| def test_add_samples(self): |
| # Check nop implicit float conversion from float. |
| self.samples_list_float.add_samples([9.9]) |
| self.assertListEqual(self.samples_list_float.data, [21.4, 3.2, 9.9]) |
| |
| # Check implicit float conversion from string. |
| self.samples_list_float.add_samples(['4.4']) |
| self.assertListEqual(self.samples_list_float.data, |
| [21.4, 3.2, 9.9, 4.4]) |
| |
| # Check explicit float conversion from integer. |
| self.samples_list_float.add_samples([2]) |
| self.assertIsInstance(self.samples_list_float.data[-1], float) |
| self.assertListEqual(self.samples_list_float.data, |
| [21.4, 3.2, 9.9, 4.4, 2.0]) |
| |
| # Check int conversion from float. |
| self.samples_list_float.add_samples([11.6], int) |
| self.assertListEqual(self.samples_list_float.data, |
| [21.4, 3.2, 9.9, 4.4, 2.0, 11]) |
| |
| def test_render(self): |
| # Check rendering with several samples. |
| self.assertDictEqual(self.samples_list_float.render(), |
| dict(execution_time=[21.4, 3.2])) |
| |
| # Check rendering with a single sample. |
| samples_list_one_float = MetricSamples('execution_time', [7.3]) |
| self.assertDictEqual(samples_list_one_float.render(), |
| dict(execution_time=7.3)) |
| |
| |
| class TestTest(unittest.TestCase): |
| def setUp(self): |
| self.samples = [MetricSamples('execution_time', [21.4, 3.2])] |
| self.test_noinfo = Test('Test1', self.samples) |
| self.test_info = Test('Test2', self.samples, {'nb_files': 2}) |
| |
| def test_constructor(self): |
| # Check default version, no extra info. |
| self.assertEqual(self.test_noinfo.name, 'Test1') |
| self.assertListEqual(self.test_noinfo.samples, self.samples) |
| self.assertDictEqual(self.test_noinfo.info, dict()) |
| self.assertEqual(self.test_noinfo.report_version, 2) |
| |
| # Check default version, extra info. |
| self.assertEqual(self.test_info.name, 'Test2') |
| self.assertListEqual(self.test_info.samples, self.samples) |
| self.assertDictEqual(self.test_info.info, dict(nb_files='2')) |
| self.assertEqual(self.test_info.report_version, 2) |
| |
| # Check explicit version, no extra info. |
| test_noinfo_version = Test('Test3', self.samples, report_version=2) |
| self.assertListEqual(test_noinfo_version.samples, self.samples) |
| self.assertDictEqual(test_noinfo_version.info, dict()) |
| self.assertEqual(test_noinfo_version.report_version, 2) |
| |
| # Check call to check(). |
| self.assertRaises(AssertionError, Test, 'Test4', self.samples, |
| report_version=1) |
| |
| def test_check(self): |
| # Check too small version. |
| self.test_noinfo.report_version = 1 |
| self.assertRaises(AssertionError, self.test_noinfo.check) |
| |
| # Check too big version. |
| self.test_noinfo.report_version = 3 |
| self.assertRaises(AssertionError, self.test_noinfo.check) |
| |
| # Check valid instance. |
| self.test_noinfo.report_version = 2 |
| self.test_noinfo.check() |
| |
| # Check wrong instance for tests. |
| self.test_noinfo.samples = [self.samples[0], 2] |
| self.assertRaises(AssertionError, self.test_noinfo.check) |
| |
| def test_render(self): |
| # Check rendering with no info. |
| d1 = {'Name': 'Test1', |
| 'execution_time': [21.4, 3.2]} |
| self.assertDictEqual(self.test_noinfo.render(), d1) |
| |
| # Check rendering with info. |
| d2 = {'Name': 'Test2', |
| 'execution_time': [21.4, 3.2], |
| 'nb_files': '2'} |
| self.assertDictEqual(self.test_info.render(), d2) |
| |
| |
| class TestTestSamples(unittest.TestCase): |
| def setUp(self): |
| self.test_samples_int_list_noinfo = TestSamples('Test1', [1, 2]) |
| self.test_samples_str_float_list_noinfo = TestSamples('Test3', |
| ['2.3', '5.8']) |
| self.test_samples_int_list_info = TestSamples('Test7', [1.7, 2.8], |
| {'nb_files': 2}) |
| |
| def test_constructor(self): |
| # Check implicit float conversion from integer. |
| self.assertEqual(self.test_samples_int_list_noinfo.name, 'Test1') |
| self.assertDictEqual(self.test_samples_int_list_noinfo.info, {}) |
| self.assertIsInstance(self.test_samples_int_list_noinfo.data[0], float) |
| self.assertIsInstance(self.test_samples_int_list_noinfo.data[1], float) |
| self.assertListEqual(self.test_samples_int_list_noinfo.data, |
| [1.0, 2.0]) |
| |
| # Check explicit float conversion from integer. |
| float_test_samples_int_list_noinfo = TestSamples('Test2', [8, 9], |
| conv_f=float) |
| self.assertEqual(float_test_samples_int_list_noinfo.name, 'Test2') |
| self.assertDictEqual(float_test_samples_int_list_noinfo.info, {}) |
| self.assertIsInstance(float_test_samples_int_list_noinfo.data[0], |
| float) |
| self.assertIsInstance(float_test_samples_int_list_noinfo.data[1], |
| float) |
| self.assertListEqual(float_test_samples_int_list_noinfo.data, |
| [8.0, 9.0]) |
| |
| # Check implicit float conversion from string. |
| self.assertEqual(self.test_samples_str_float_list_noinfo.name, 'Test3') |
| self.assertDictEqual(self.test_samples_str_float_list_noinfo.info, {}) |
| self.assertListEqual(self.test_samples_str_float_list_noinfo.data, |
| [2.3, 5.8]) |
| |
| # Check implicit nop float conversion from float. |
| test_samples_float_list_noinfo = TestSamples('Test4', [6.4, 5.5]) |
| self.assertEqual(test_samples_float_list_noinfo.name, 'Test4') |
| self.assertDictEqual(test_samples_float_list_noinfo.info, {}) |
| self.assertListEqual(test_samples_float_list_noinfo.data, [6.4, 5.5]) |
| |
| # Check nop non-float conversion from input of same type. |
| int_test_samples_int_list_noinfo = TestSamples('Test5', [1, 2], |
| conv_f=int) |
| self.assertEqual(int_test_samples_int_list_noinfo.name, 'Test5') |
| self.assertDictEqual(int_test_samples_int_list_noinfo.info, {}) |
| self.assertListEqual(int_test_samples_int_list_noinfo.data, [1, 2]) |
| |
| # Check non-float conversion from string. |
| int_test_samples_float_list_noinfo = TestSamples('Test6', [6.4, 5.5], |
| conv_f=int) |
| self.assertEqual(int_test_samples_float_list_noinfo.name, 'Test6') |
| self.assertDictEqual(int_test_samples_float_list_noinfo.info, {}) |
| self.assertListEqual(int_test_samples_float_list_noinfo.data, [6, 5]) |
| |
| # Check non-float conversion from float. |
| self.assertEqual(self.test_samples_int_list_info.name, 'Test7') |
| self.assertDictEqual(self.test_samples_int_list_info.info, |
| {'nb_files': '2'}) |
| self.assertListEqual(self.test_samples_int_list_info.data, [1.7, 2.8]) |
| |
| def test_render(self): |
| # Check rendering with no info. |
| d1 = {'Name': 'Test3', |
| 'Info': {}, |
| 'Data': [2.3, 5.8]} |
| self.assertDictEqual(self.test_samples_str_float_list_noinfo.render(), |
| d1) |
| |
| # Check rendering with info. |
| d2 = {'Name': 'Test7', |
| 'Info': {'nb_files': '2'}, |
| 'Data': [1.7, 2.8]} |
| self.assertDictEqual(self.test_samples_int_list_info.render(), d2) |
| |
| |
| 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) |
| |
| |
| class TestMachine(unittest.TestCase): |
| def setUp(self): |
| self.machine_v1_noinfo = Machine('Machine1') |
| self.machine_v1 = Machine('Machine2', {'CPUs': 2}) |
| self.machine_v2 = Machine('Machine3', {'CPUs': 2}, 2) |
| |
| def test_constructor(self): |
| # Check constructor with no info and default version (v1). |
| self.assertEqual(self.machine_v1_noinfo.name, 'Machine1') |
| self.assertDictEqual(self.machine_v1_noinfo.info, {}) |
| self.assertEqual(self.machine_v1_noinfo.report_version, 1) |
| |
| # Check constructor with info and default version (v1). |
| self.assertEqual(self.machine_v1.name, 'Machine2') |
| self.assertDictEqual(self.machine_v1.info, {'CPUs': '2'}) |
| self.assertEqual(self.machine_v1.report_version, 1) |
| |
| # Check v2 constructor with info. |
| self.assertEqual(self.machine_v2.name, 'Machine3') |
| self.assertDictEqual(self.machine_v2.info, {'CPUs': '2'}) |
| self.assertEqual(self.machine_v2.report_version, 2) |
| |
| def test_check(self): |
| # Check valid v1 instance. |
| self.machine_v1.check() |
| |
| # Check valid v2 instance. |
| self.machine_v2.check() |
| |
| # Check too big version. |
| self.machine_v2.report_version = 3 |
| self.assertRaises(AssertionError, self.machine_v2.check) |
| |
| def test_render(self): |
| # Check v1 rendering with no info. |
| d1 = {'Name': 'Machine1', |
| 'Info': {}} |
| self.assertDictEqual(self.machine_v1_noinfo.render(), d1) |
| |
| # Check v1 rendering with info. |
| d2 = {'Name': 'Machine2', |
| 'Info': {'CPUs': '2'}} |
| self.assertDictEqual(self.machine_v1.render(), d2) |
| |
| # Check v2 rendering with no info. |
| d3 = {'Name': 'Machine3', |
| 'CPUs': '2'} |
| self.assertDictEqual(self.machine_v2.render(), d3) |
| |
| # Check v2 rendering with info. |
| self.machine_v2.info = {} |
| d4 = {'Name': 'Machine3'} |
| self.assertDictEqual(self.machine_v2.render(), d4) |
| |
| |
| class TestReport(unittest.TestCase): |
| maxDiff = None |
| |
| 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 test_constructor(self): |
| # Check successful constructor call with default version. |
| self.assertEqual(self.report_v1.machine, self.machine_v1) |
| self.assertEqual(self.report_v1.run, self.run_v1) |
| self.assertListEqual(self.report_v1.tests, self.tests_samples) |
| self.assertEqual(self.report_v1.report_version, 1) |
| |
| # Check successful constructor call with explicit version. |
| self.assertEqual(self.report_v2.machine, self.machine_v2) |
| self.assertEqual(self.report_v2.run, self.run_v2) |
| self.assertListEqual(self.report_v2.tests, self.tests) |
| self.assertEqual(self.report_v2.report_version, 2) |
| |
| # Check call to check(). |
| self.assertRaises(AssertionError, Report, [], self.run_v1, |
| self.tests_samples) |
| |
| def test_check(self): |
| # Check wrong version. |
| self.report_v2.report_version = 3 |
| self.assertRaises(AssertionError, self.report_v2.check) |
| |
| # Check valid v2 report. |
| self.report_v2.report_version = 2 |
| self.report_v2.check() |
| |
| # Check type test for machine. |
| report_machine_list = copy.deepcopy(self.report_v1) |
| report_machine_list.machine = [] |
| self.assertRaises(AssertionError, report_machine_list.check) |
| |
| # Check version mismatch between machine and report. |
| self.report_v1.machine.report_version = 2 |
| self.assertRaises(AssertionError, self.report_v1.check) |
| |
| # Check valid v1 report. |
| self.report_v1.machine.report_version = 1 |
| self.report_v1.check() |
| |
| # Check type test for run. |
| report_run_list = copy.deepcopy(self.report_v1) |
| report_run_list.run = [] |
| self.assertRaises(AssertionError, report_run_list.check) |
| |
| # Check version mismatch between run and report. |
| self.report_v1.run.report_version = 2 |
| self.assertRaises(AssertionError, self.report_v1.check) |
| |
| self.report_v1.run.report_version = 1 |
| |
| # Check type test for all v1 tests. |
| report_v1_tests_int_list = copy.deepcopy(self.report_v1) |
| report_v1_tests_int_list.tests = [2] |
| self.assertRaises(AssertionError, report_v1_tests_int_list.check) |
| |
| # Check type test for all v2 tests. |
| report_v2_tests_int_list = copy.deepcopy(self.report_v2) |
| report_v2_tests_int_list.tests = [2] |
| self.assertRaises(AssertionError, report_v2_tests_int_list.check) |
| |
| # Check version mismatch between one of the tests and report. |
| self.report_v2.tests[0].report_version = 1 |
| self.assertRaises(AssertionError, self.report_v2.check) |
| |
| def test_update_report(self): |
| # Check update with default (=now) end time. |
| orig_end_time = self.report_v1.run.end_time |
| new_tests_samples = [TestSamples('Test2.exec', [56.5])] |
| self.report_v1.update_report(new_tests_samples) |
| self.tests_samples.extend(new_tests_samples) |
| self.assertListEqual(self.report_v1.tests, self.tests_samples) |
| self.assertNotEqual(self.report_v1.run.end_time, orig_end_time) |
| |
| # Check update with supplied end time. |
| new_tests_samples = [TestSamples('Test3.exec', [18.3])] |
| self.report_v1.update_report(new_tests_samples, '1990-07-07 00:00:00') |
| self.tests_samples.extend(new_tests_samples) |
| self.assertListEqual(self.report_v1.tests, self.tests_samples) |
| self.assertEqual(self.report_v1.run.end_time, '1990-07-07 00:00:00') |
| |
| def test_render(self): |
| # Check v1 format rendering with default indentation. |
| self.assertMultiLineEqual(re.sub(r' +\n', '\n', |
| self.report_v1.render()), """\ |
| { |
| "Machine": { |
| "Info": { |
| "nb_cpus": "2" |
| }, |
| "Name": "Machine" |
| }, |
| "Run": { |
| "End Time": "1982-01-01 00:00:00", |
| "Info": { |
| "__report_version__": "1", |
| "run_order": "18246", |
| "tag": "nts" |
| }, |
| "Start Time": "1970-01-01 00:00:00" |
| }, |
| "Tests": [ |
| { |
| "Data": [ |
| 1.7, |
| 2.8 |
| ], |
| "Info": { |
| "nb_files": "2" |
| }, |
| "Name": "Test.exec" |
| } |
| ] |
| }""") |
| |
| # Check v1 format rendering with supplied indentation. |
| self.assertMultiLineEqual(re.sub(r' +\n', '\n', |
| self.report_v1.render(indent=2)), """\ |
| { |
| "Machine": { |
| "Info": { |
| "nb_cpus": "2" |
| }, |
| "Name": "Machine" |
| }, |
| "Run": { |
| "End Time": "1982-01-01 00:00:00", |
| "Info": { |
| "__report_version__": "1", |
| "run_order": "18246", |
| "tag": "nts" |
| }, |
| "Start Time": "1970-01-01 00:00:00" |
| }, |
| "Tests": [ |
| { |
| "Data": [ |
| 1.7, |
| 2.8 |
| ], |
| "Info": { |
| "nb_files": "2" |
| }, |
| "Name": "Test.exec" |
| } |
| ] |
| }""") |
| |
| # Check v2 format rendering with default indentation. |
| self.assertMultiLineEqual(re.sub(r' +\n', '\n', |
| self.report_v2.render()), """\ |
| { |
| "format_version": "2", |
| "machine": { |
| "Name": "Machine", |
| "nb_cpus": "2" |
| }, |
| "run": { |
| "llvm_project_revision": "18246", |
| "start_time": "1970-01-01 00:00:00" |
| }, |
| "tests": [ |
| { |
| "Name": "Test", |
| "execution_time": [ |
| 21.4, |
| 3.2 |
| ], |
| "nb_files": "2" |
| } |
| ] |
| }""") |
| |
| # Check v2 format rendering with supplied indentation. |
| self.assertMultiLineEqual(re.sub(r' +\n', '\n', |
| self.report_v2.render(indent=2)), """\ |
| { |
| "format_version": "2", |
| "machine": { |
| "Name": "Machine", |
| "nb_cpus": "2" |
| }, |
| "run": { |
| "llvm_project_revision": "18246", |
| "start_time": "1970-01-01 00:00:00" |
| }, |
| "tests": [ |
| { |
| "Name": "Test", |
| "execution_time": [ |
| 21.4, |
| 3.2 |
| ], |
| "nb_files": "2" |
| } |
| ] |
| }""") |
| |
| # Check v2 format rendering with single sample for a metric and |
| # default indentation. |
| self.report_v2.tests[0].samples[0].data.pop() |
| self.assertMultiLineEqual(re.sub(r' +\n', '\n', |
| self.report_v2.render()), """\ |
| { |
| "format_version": "2", |
| "machine": { |
| "Name": "Machine", |
| "nb_cpus": "2" |
| }, |
| "run": { |
| "llvm_project_revision": "18246", |
| "start_time": "1970-01-01 00:00:00" |
| }, |
| "tests": [ |
| { |
| "Name": "Test", |
| "execution_time": 21.4, |
| "nb_files": "2" |
| } |
| ] |
| }""") |
| |
| |
| if __name__ == '__main__': |
| unittest.main(argv=[sys.argv[0], ]) |
