/
test_formatter.py
148 lines (116 loc) · 5.7 KB
/
test_formatter.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import pygsti.report.formatters as fmt
from pygsti.report.latex import value as latex_value
from pygsti.report.table import ReportTable
from ..util import BaseCase
def render_pair(heading, formatter, formattype='latex', **kwargs):
# TODO render directly instead of through ReportTable
table = ReportTable([heading], [formatter])
return table.render(formattype, **kwargs)[formattype]
class FormatterTester(BaseCase):
def setUp(self):
super(FormatterTester, self).setUp()
def test_none_formatter(self):
fmt.format_dict['BadFormat'] = {
'latex': lambda l, s: None,
'html': lambda l, s: None,
'text': lambda l, s: None,
'ppt': lambda l, s: None,
}
with self.assertRaises(AssertionError):
render_pair('some_heading', 'BadFormat')
def test_unformatted_none(self):
with self.assertRaises(ValueError):
render_pair(None, None)
def test_unformatted(self):
render_pair('some heading', None)
# TODO assert correctness
def test_string_return(self):
self.assertEqual(
render_pair('Ec', 'Effect', 'html'),
('<table><thead><tr><th> <span title="Ec">E<sub>C</sub></span> </th></tr></thead>'
'<tbody></tbody></table>')
)
def test_string_replace(self):
self.assertEqual(
render_pair('rho0', 'Rho', 'html'),
('<table><thead><tr><th> <span title="rho0">ρ<sub>0</sub></span> </th></tr></thead>'
'<tbody></tbody></table>')
)
def test_conversion_formatters(self):
self.assertEqual(fmt.convert_html('|<STAR>', {}), ' ★')
self.assertEqual(
fmt.convert_latex('%% # half-width 1/2 Diamond Check <STAR>', {}),
'$\%\% \# $\\nicefrac{1}{2}$-width $\\nicefrac{1}{2}$ $\Diamond$ \checkmark \\bigstar$'
)
self.assertEqual(fmt.convert_latex('x|y', {}), '\\begin{tabular}{c}x\\\\y\end{tabular}')
def test_value_fns(self):
specs = {'precision': 2, 'sciprecision': 2, 'polarprecision': 2, 'complex_as_polar': True}
self.assertEqual(latex_value("Hello", specs), "Hello")
latex_value({"Weird type": "to get value of!"}, specs)
#More variants?
# Refactored from test.test_packages.reportb.testEBFormatters
# TODO assert correct elements instead of directly comparing rendered strings
class EBFormatterBase(object):
def test_render_EB_formatter(self):
n = 1.819743 # Six digits after decimal
render = render_pair((n, n), self.formatter, formattype=self.target, precision=6)
self.assertEqual(render, self.expected_eb_fmt.format(n))
n = 1.82 # Two digits after decimal
render = render_pair((n, n), self.formatter, formattype=self.target, precision=2)
self.assertEqual(render, self.expected_eb_fmt.format(n))
def test_render_EB_formatter_none(self):
n = 1.819743 # Six digits after decimal
render = render_pair((n, None), self.formatter, formattype=self.target, precision=6)
self.assertEqual(render, self.expected_no_eb_fmt.format(n))
n = 1.82 # Two digits after decimal
render = render_pair((n, None), self.formatter, formattype=self.target, precision=2)
self.assertEqual(render, self.expected_no_eb_fmt.format(n))
class NormalEBFormatterTester(EBFormatterBase, BaseCase):
formatter = 'Normal'
target = 'latex'
expected_eb_fmt = (
'\\begin{{tabular}}[l]{{|c|}}\n\\hline\n$ \\begin{{array}}{{c}} {0} \\\\ '
'\\pm {0} \\end{{array}} $ \\\\ \\hline\n\\end{{tabular}}\n'
)
expected_no_eb_fmt = '\\begin{{tabular}}[l]{{|c|}}\n\\hline\n{0} \\\\ \\hline\n\\end{{tabular}}\n'
class PiLaTeXEBFormatterTester(EBFormatterBase, BaseCase):
formatter = 'Pi'
target = 'latex'
expected_eb_fmt = (
'\\begin{{tabular}}[l]{{|c|}}\n\\hline\n$ \\begin{{array}}{{c}}({0} \\\\ '
'\\pm {0})\\pi \\end{{array}} $ \\\\ \\hline\n\\end{{tabular}}\n'
)
expected_no_eb_fmt = '\\begin{{tabular}}[l]{{|c|}}\n\\hline\n{0}$\\pi$ \\\\ \\hline\n\\end{{tabular}}\n'
class PiHTMLEBFormatterTester(EBFormatterBase, BaseCase):
formatter = 'Pi'
target = 'html'
expected_eb_fmt = (
'<table><thead><tr><th> <span title="({0}, {0})">{0}π <span class="errorbar">± '
'{0}</span>π</span> </th></tr></thead><tbody></tbody></table>'
)
expected_no_eb_fmt = (
'<table><thead><tr><th> <span title="({0}, None)">{0}π</span> </th></tr></thead>'
'<tbody></tbody></table>'
)
class PrecisionFormatterBase(object):
expected_LaTeX_fmt = '\\begin{{tabular}}[l]{{|c|}}\n\hline\n{0} \\\\ \hline\n\end{{tabular}}\n'
expected_HTML_fmt = '<table><thead><tr><th> <span title="{0}">{1}</span> </th></tr></thead><tbody></tbody></table>'
def setUp(self):
super(PrecisionFormatterBase, self).setUp()
n = 1.819743 # Six digits after decimal
self.table = ReportTable([n], ['Normal'])
self.options = dict(
precision=self.precision,
polarprecision=3
)
format_n = "{{:.{}f}}".format(self.precision).format(n)
self.expected_LaTeX = self.expected_LaTeX_fmt.format(format_n)
self.expected_HTML = self.expected_HTML_fmt.format(n, format_n)
def test_render_precision_LaTeX(self):
self.assertEqual(self.table.render('latex', **self.options)['latex'], self.expected_LaTeX)
def test_render_precision_HTML(self):
self.assertEqual(self.table.render('html', **self.options)['html'], self.expected_HTML)
class HighPrecisionFormatterTester(PrecisionFormatterBase, BaseCase):
precision = 6
class LowPrecisionFormatterTester(PrecisionFormatterBase, BaseCase):
precision = 2