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)