[benchmark] ReportFormatter: better inline headers

Improve inline headers in `single_table` mode to also print labels for the numeric columns.

Sections in the `single_table` are visually distinguished by a separator row preceding the the inline headers.

Separated header label styles for git and markdown modes with UPPERCASE and **Bold**  formatting respectively.

Inlined section template definitions.

Author: palimondo

Diff for: benchmark/scripts/compare_perf_tests.py

@@ -547,15 +547,6 @@ def __init__(self, comparator, changes_only,
         self.changes_only = changes_only
         self.single_table = single_table
 
-    MARKDOWN_DETAIL = """
-<details {3}>
-  <summary>{0} ({1})</summary>
-  {2}
-</details>
-"""
-    GIT_DETAIL = """
-{0} ({1}): {2}"""
-
     PERFORMANCE_TEST_RESULT_HEADER = ('TEST', 'MIN', 'MAX', 'MEAN', 'MAX_RSS')
     RESULT_COMPARISON_HEADER = ('TEST', 'OLD', 'NEW', 'DELTA', 'RATIO')
 
@@ -589,16 +580,26 @@ def values(result):
     def markdown(self):
         """Report results of benchmark comparisons in Markdown format."""
         return self._formatted_text(
+            label_formatter=lambda s: ('**' + s + '**'),
             COLUMN_SEPARATOR=' | ',
-            HEADER_SEPARATOR='---',
-            DETAIL=self.MARKDOWN_DETAIL)
+            DELIMITER_ROW=([':---'] + ['---:'] * 4),
+            SEPARATOR='&nbsp; | | | | \n',
+            SECTION="""
+<details {3}>
+  <summary>{0} ({1})</summary>
+  {2}
+</details>
+""")
 
     def git(self):
         """Report results of benchmark comparisons in 'git' format."""
         return self._formatted_text(
+            label_formatter=lambda s: s.upper(),
             COLUMN_SEPARATOR='   ',
-            HEADER_SEPARATOR='   ',
-            DETAIL=self.GIT_DETAIL)
+            DELIMITER_ROW=None,
+            SEPARATOR='\n',
+            SECTION="""
+{0} ({1}): \n{2}""")
 
     def _column_widths(self):
         changed = self.comparator.decreased + self.comparator.increased
@@ -618,24 +619,24 @@ def max_widths(maximum, widths):
 
         return reduce(max_widths, widths, [0] * 5)
 
-    def _formatted_text(self, COLUMN_SEPARATOR, HEADER_SEPARATOR, DETAIL):
+    def _formatted_text(self, label_formatter, COLUMN_SEPARATOR,
+                        DELIMITER_ROW, SEPARATOR, SECTION):
         widths = self._column_widths()
         self.header_printed = False
 
         def justify_columns(contents):
             return [c.ljust(w) for w, c in zip(widths, contents)]
 
         def row(contents):
-            return COLUMN_SEPARATOR.join(justify_columns(contents)) + ' \n'
+            return ('' if not contents else
+                    COLUMN_SEPARATOR.join(justify_columns(contents)) + '\n')
 
         def header(title, column_labels):
-            h = ''
-            if not self.header_printed:
-                h = '\n' + row(column_labels)
-                h += row([':' + HEADER_SEPARATOR] +  # left align 1st column
-                         ([HEADER_SEPARATOR + ':']) * 4)  # right align rest
-            if self.single_table:
-                h += row(('**' + title + '**', '', '', '', ''))
+            labels = (column_labels if not self.single_table else
+                      map(label_formatter, (title, ) + column_labels[1:]))
+            h = (('' if not self.header_printed else SEPARATOR) +
+                 row(labels) +
+                 (row(DELIMITER_ROW) if not self.header_printed else ''))
             if self.single_table and not self.header_printed:
                 self.header_printed = True
             return h
@@ -645,19 +646,20 @@ def format_columns(r, is_strong):
                     r[:-1] + ('**' + r[-1] + '**', ))
 
         def table(title, results, is_strong=False, is_open=False):
+            if not results:
+                return ''
             rows = [
                 row(format_columns(ReportFormatter.values(r), is_strong))
                 for r in results
             ]
             table = (header(title if self.single_table else '',
                             ReportFormatter.header_for(results[0])) +
                      ''.join(rows))
-            return '' if not rows else (
-                (table if self.single_table else
-                 DETAIL.format(
-                     title, len(results), table, 'open' if is_open else '')))
+            return (table if self.single_table else
+                    SECTION.format(
+                        title, len(results), table, 'open' if is_open else ''))
 
-        return ''.join([
+        return '\n' + ''.join([
             table('Regression', self.comparator.decreased, True, True),
             table('Improvement', self.comparator.increased, True),
             ('' if self.changes_only else

Diff for: benchmark/scripts/test_compare_perf_tests.py

@@ -857,15 +857,33 @@ def test_report_only_changes(self):
 
     def test_single_table_report(self):
         """Single table report has bold inline headers and no sections."""
+        self.tc.removed = []  # test handling empty section
         rf = ReportFormatter(self.tc, changes_only=True, single_table=True)
         markdown = rf.markdown()
-        self.assertNotIn('<details', markdown)
+        self.assertNotIn('<details', markdown)  # no sections
+        self.assertNotIn('\n\n', markdown)  # table must not be broken
+        self.assertNotIn('Removed', markdown)
         self.assert_report_contains([
-            '**Regression**', '**Added**',
-            '| OLD', '| NEW', '| DELTA', '| RATIO'
+            '\n**Regression** ',
+            '| **OLD**', '| **NEW**', '| **DELTA**', '| **RATIO**',
+            '\n**Added** ',
+            '| **MIN**', '| **MAX**', '| **MEAN**', '| **MAX_RSS**'
         ], markdown)
+        # Single delimiter row:
         self.assertIn('\n:---', markdown)  # first column is left aligned
         self.assertEqual(markdown.count('| ---:'), 4)  # other, right aligned
+        # Separator before every inline header (new section):
+        self.assertEqual(markdown.count('&nbsp; | | | | '), 2)
+
+        git = rf.git()
+        self.assertNotIn('): \n', git)  # no sections
+        self.assertNotIn('REMOVED', git)
+        self.assert_report_contains([
+            '\nREGRESSION ', ' OLD ', ' NEW ', ' DELTA ', ' RATIO ',
+            '\n\nADDED ', ' MIN ', ' MAX ', ' MEAN ', ' MAX_RSS '
+        ], git)
+        # Separator before every inline header (new section):
+        self.assertEqual(git.count('\n\n'), 2)
 
 
 class Test_parse_args(unittest.TestCase):