def test_too_large(self):
fmt = M.FormatString('%{0}d'.format(M.SSIZE_MAX))
assert_equal(len(fmt), 1)
assert_equal(len(fmt.seq_arguments), 1)
assert_equal(len(fmt.map_arguments), 0)
with assert_raises(M.WidthRangeError):
M.FormatString('%{0}d'.format(M.SSIZE_MAX + 1))
def t(s, tp):
fmt = M.FormatString(s)
assert_equal(len(fmt.seq_arguments), 0)
[args] = fmt.map_arguments.values()
assert_greater(len(args), 1)
for arg in args:
assert_equal(arg.type, tp)
def test_text():
fmt = M.FormatString('eggs%dbacon%dspam')
assert_equal(len(fmt), 5)
fmt = list(fmt)
assert_equal(fmt[0], 'eggs')
assert_equal(fmt[2], 'bacon')
assert_equal(fmt[4], 'spam')
def t(self, key):
s = '%(' + key + ')s'
fmt = M.FormatString(s)
assert_equal(len(fmt), 1)
assert_sequence_equal(fmt.seq_arguments, [])
[pkey] = fmt.map_arguments.keys()
assert_equal(key, pkey)
def test_variable(self):
fmt = M.FormatString('%.*f')
assert_equal(len(fmt), 1)
assert_equal(len(fmt.map_arguments), 0)
[a1, a2] = fmt.seq_arguments
assert_equal(a1.type, 'int')
assert_equal(a2.type, 'float')
def check_string(self, ctx, message, s):
prefix = message_repr(message, template='{}:')
fmt = None
try:
fmt = backend.FormatString(s)
except backend.ArgumentTypeMismatch as exc:
[s, key, types] = exc.args # pylint: disable=unbalanced-tuple-unpacking
self.tag(
'python-format-string-error',
prefix,
tags.safestr(exc.message),
tags.safestr(key),
tags.safestr(', '.join(sorted(x for x in types))),
)
except backend.Error as exc:
self.tag('python-format-string-error', prefix,
tags.safestr(exc.message), *exc.args[:1])
if fmt is None:
return
for warn in fmt.warnings:
try:
raise warn
except backend.RedundantFlag as exc:
if len(exc.args) == 2:
[s, *args] = exc.args
else:
[s, a1, a2] = exc.args
if a1 == a2:
args = ['duplicate', a1]
else:
args = [a1, tags.safe_format('overridden by {}', a2)]
args += ['in', s]
self.tag('python-format-string-redundant-flag', prefix, *args)
except backend.RedundantPrecision as exc:
[s, a] = exc.args
self.tag('python-format-string-redundant-precision', prefix, a,
'in', s)
except backend.RedundantLength as exc:
[s, a] = exc.args
self.tag('python-format-string-redundant-length', prefix, a,
'in', s)
except backend.ObsoleteConversion as exc:
[s, c1, c2] = exc.args
args = [c1, '=>', c2]
if s != c1:
args += ['in', s]
self.tag('python-format-string-obsolete-conversion', prefix,
*args)
if ctx.is_template:
if len(fmt.seq_conversions) > 1:
self.tag('python-format-string-multiple-unnamed-arguments',
message_repr(message))
elif len(fmt.seq_conversions) == 1:
arg_for_plural = (message.msgid_plural is not None
and fmt.seq_conversions[0].type == 'int')
if arg_for_plural:
self.tag('python-format-string-unnamed-plural-argument',
message_repr(message))
return fmt
def t(s, expected):
fmt = M.FormatString(s)
assert_equal(len(fmt), 1)
if expected:
assert_sequence_equal(fmt.warnings, [])
else:
[exc] = fmt.warnings
assert_is_instance(exc, M.RedundantFlag)
def t(self, s, tp, warn_type=None):
fmt = M.FormatString(s)
[conv] = fmt
assert_is_instance(conv, M.Conversion)
assert_equal(conv.type, tp)
assert_equal(len(fmt.map_arguments), 0)
if tp == 'None':
assert_sequence_equal(fmt.seq_arguments, [])
else:
[arg] = fmt.seq_arguments
assert_equal(arg.type, tp)
if warn_type is None:
assert_equal(len(fmt.warnings), 0)
else:
[warning] = fmt.warnings
assert_is_instance(warning, warn_type)
def test_percent(self):
with assert_raises(M.ForbiddenArgumentKey):
M.FormatString('%(eggs)%')
def t(self, s):
fmt = M.FormatString(s)
[exc] = fmt.warnings
assert_is_instance(exc, M.RedundantFlag)
def test_add_argument():
fmt = M.FormatString('%s')
with assert_raises(RuntimeError):
fmt.add_argument(None, None)
with assert_raises(RuntimeError):
fmt.add_argument('eggs', None)
def test_invalid_conversion_spec():
with assert_raises(M.Error):
M.FormatString('%!')
def test_lone_percent():
with assert_raises(M.Error):
M.FormatString('%')
def t(s, n):
fmt = M.FormatString(s)
assert_equal(len(fmt.seq_conversions), n)
for arg in fmt.seq_conversions:
assert_is_instance(arg, M.Conversion)
def t(s):
with assert_raises(M.ArgumentTypeMismatch):
M.FormatString(s)
def t(s):
with assert_raises(M.ArgumentIndexingMixture):
M.FormatString(s)
def t(l):
fmt = M.FormatString('%' + l + 'd')
[warning] = fmt.warnings
assert_is_instance(warning, M.RedundantLength)
def test_too_large(self):
fmt = M.FormatString('%.{0}f'.format(M.SSIZE_MAX))
assert_equal(len(fmt), 1)
with assert_raises(M.PrecisionRangeError):
M.FormatString('%.{0}f'.format(M.SSIZE_MAX + 1))
def t(s):
fmt = M.FormatString(s)
assert_equal(len(fmt), 1)
[warning] = fmt.warnings
assert_is_instance(warning, M.RedundantPrecision)
def t(s):
fmt = M.FormatString(s)
assert_equal(len(fmt), 1)
assert_sequence_equal(fmt.warnings, [])
def t(s):
fmt = M.FormatString(s)
assert_equal(len(fmt), 1)
