Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-11-03 23:21:29 +00:00
Code Issues Projects Releases Packages Wiki Activity
cpython/Lib/test/test_pep292.py

195 lines
7.5 KiB
Python
Raw Normal View History

PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
# Copyright (C) 2004 Python Software Foundation
# Author: barry@python.org (Barry Warsaw)
# License: http://www.opensource.org/licenses/PythonSoftFoundation.php
import unittest
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
from string import Template
class Bag:
pass
class Mapping:
def __getitem__(self, name):
obj = self
for part in name.split('.'):
try:
obj = getattr(obj, part)
except AttributeError:
raise KeyError(name)
return obj
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
class TestTemplate(unittest.TestCase):
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_regular_templates(self):
s = Template('$who likes to eat a bag of $what worth $$100')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
self.assertEqual(s.substitute(dict(who='tim', what='ham')),
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
'tim likes to eat a bag of ham worth $100')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
self.assertRaises(KeyError, s.substitute, dict(who='tim'))
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_regular_templates_with_braces(self):
s = Template('$who likes ${what} for ${meal}')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
d = dict(who='tim', what='ham', meal='dinner')
self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
self.assertRaises(KeyError, s.substitute,
dict(who='tim', what='ham'))
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_escapes(self):
eq = self.assertEqual
s = Template('$who likes to eat a bag of $$what worth $$100')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
eq(s.substitute(dict(who='tim', what='ham')),
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
'tim likes to eat a bag of $what worth $100')
s = Template('$who likes $$')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $')
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_percents(self):
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
eq = self.assertEqual
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
s = Template('%(foo)s $foo ${foo}')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
d = dict(foo='baz')
eq(s.substitute(d), '%(foo)s baz baz')
eq(s.safe_substitute(d), '%(foo)s baz baz')
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_stringification(self):
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
eq = self.assertEqual
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
s = Template('tim has eaten $count bags of ham today')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
d = dict(count=7)
eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
eq(s.safe_substitute(d), 'tim has eaten 7 bags of ham today')
s = Template('tim has eaten ${count} bags of ham today')
eq(s.substitute(d), 'tim has eaten 7 bags of ham today')
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
Fix bug in passing tuples to string.Template. All other values (with working str() or repr()) would work, just not multi-value tuples. Probably not a backport candidate, since it changes the behaviour of passing a single-element tuple: >>> string.Template("$foo").substitute(dict(foo=(1,))) '(1,)' versus '1'
2006-07-05 11:03:49 +00:00
def test_tupleargs(self):
eq = self.assertEqual
s = Template('$who ate ${meal}')
d = dict(who=('tim', 'fred'), meal=('ham', 'kung pao'))
eq(s.substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
eq(s.safe_substitute(d), "('tim', 'fred') ate ('ham', 'kung pao')")
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_SafeTemplate(self):
eq = self.assertEqual
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
s = Template('$who likes ${what} for ${meal}')
eq(s.safe_substitute(dict(who='tim')), 'tim likes ${what} for ${meal}')
eq(s.safe_substitute(dict(what='ham')), '$who likes ham for ${meal}')
eq(s.safe_substitute(dict(what='ham', meal='dinner')),
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
'$who likes ham for dinner')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
eq(s.safe_substitute(dict(who='tim', what='ham')),
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
'tim likes ham for ${meal}')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
eq(s.safe_substitute(dict(who='tim', what='ham', meal='dinner')),
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
'tim likes ham for dinner')
def test_invalid_placeholders(self):
raises = self.assertRaises
s = Template('$who likes $')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
raises(ValueError, s.substitute, dict(who='tim'))
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
s = Template('$who likes ${what)')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
raises(ValueError, s.substitute, dict(who='tim'))
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
s = Template('$who likes $100')
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
raises(ValueError, s.substitute, dict(who='tim'))
def test_delimiter_override(self):
class PieDelims(Template):
delimiter = '@'
s = PieDelims('@who likes to eat a bag of @{what} worth $100')
self.assertEqual(s.substitute(dict(who='tim', what='ham')),
'tim likes to eat a bag of ham worth $100')
def test_idpattern_override(self):
class PathPattern(Template):
idpattern = r'[_a-z][._a-z0-9]*'
m = Mapping()
m.bag = Bag()
m.bag.foo = Bag()
m.bag.foo.who = 'tim'
m.bag.what = 'ham'
s = PathPattern('$bag.foo.who likes to eat a bag of $bag.what')
self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
def test_pattern_override(self):
class MyPattern(Template):
pattern = r"""
(?P<escaped>@{2}) |
@(?P<named>[_a-z][._a-z0-9]*) |
@{(?P<braced>[_a-z][._a-z0-9]*)} |
The 4th group is now 'invalid' instead of 'bogus'.
2004-09-13 20:53:27 +00:00
(?P<invalid>@)
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
"""
m = Mapping()
m.bag = Bag()
m.bag.foo = Bag()
m.bag.foo.who = 'tim'
m.bag.what = 'ham'
s = MyPattern('@bag.foo.who likes to eat a bag of @bag.what')
self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
Invalid patterns to substitute and safe_substitute would crash since pattern is not a local variable. Add a test case.
2004-10-17 16:27:18 +00:00
class BadPattern(Template):
pattern = r"""
(?P<badname>.*) |
(?P<escaped>@{2}) |
@(?P<named>[_a-z][._a-z0-9]*) |
@{(?P<braced>[_a-z][._a-z0-9]*)} |
(?P<invalid>@) |
"""
s = BadPattern('@bag.foo.who likes to eat a bag of @bag.what')
self.assertRaises(ValueError, s.substitute, {})
self.assertRaises(ValueError, s.safe_substitute, {})
Many updates to PEP 292 templates. Summary: - Template no longer inherits from unicode. - SafeTemplate is removed. Now Templates have both a substitute() and a safe_substitute() method, so we don't need separate classes. No more __mod__() operator. - Adopt Tim Peter's idea for giving Template a metaclass, which makes the delimiter, the identifier pattern, or the entire pattern easy to override and document, while retaining efficiency of class-time compilation of the regexp. - More informative ValueError messages which will help a user narrow down the bogus delimiter to the line and column in the original string (helpful for long triple quoted strings).
2004-09-10 03:08:08 +00:00
def test_unicode_values(self):
s = Template('$who likes $what')
d = dict(who=u't\xffm', what=u'f\xfe\fed')
self.assertEqual(s.substitute(d), u't\xffm likes f\xfe\x0ced')
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
Add tests for keyword arguments and combining mapping and keyword arguments.
2004-09-13 14:35:59 +00:00
def test_keyword_arguments(self):
eq = self.assertEqual
s = Template('$who likes $what')
eq(s.substitute(who='tim', what='ham'), 'tim likes ham')
eq(s.substitute(dict(who='tim'), what='ham'), 'tim likes ham')
eq(s.substitute(dict(who='fred', what='kung pao'),
who='tim', what='ham'),
'tim likes ham')
s = Template('the mapping is $mapping')
eq(s.substitute(dict(foo='none'), mapping='bozo'),
'the mapping is bozo')
eq(s.substitute(dict(mapping='one'), mapping='two'),
'the mapping is two')
def test_keyword_arguments_safe(self):
eq = self.assertEqual
Added a test for # positional arguments > 1.
2004-09-13 15:24:43 +00:00
raises = self.assertRaises
Add tests for keyword arguments and combining mapping and keyword arguments.
2004-09-13 14:35:59 +00:00
s = Template('$who likes $what')
eq(s.safe_substitute(who='tim', what='ham'), 'tim likes ham')
eq(s.safe_substitute(dict(who='tim'), what='ham'), 'tim likes ham')
eq(s.safe_substitute(dict(who='fred', what='kung pao'),
who='tim', what='ham'),
'tim likes ham')
s = Template('the mapping is $mapping')
eq(s.safe_substitute(dict(foo='none'), mapping='bozo'),
'the mapping is bozo')
eq(s.safe_substitute(dict(mapping='one'), mapping='two'),
'the mapping is two')
Added a test for # positional arguments > 1.
2004-09-13 15:24:43 +00:00
d = dict(mapping='one')
raises(TypeError, s.substitute, d, {})
raises(TypeError, s.safe_substitute, d, {})
Add tests for keyword arguments and combining mapping and keyword arguments.
2004-09-13 14:35:59 +00:00
Fix small bugs in Template code. * The parameterization of "delimiter" was incomplete. * safe_substitute's code for braced delimiters should only be executed when braced is not None. * Invalid pattern group names now raise a ValueError. Formerly, the convert code would fall off the end and improperly return None. Beefed-up tests. * Test delimiter override for all paths in substitute and safe_substitute. * Alter unittest invocation to match other modules (now it itemizes the tests as they are run).
2004-09-14 02:34:08 +00:00
def test_delimiter_override(self):
SF patch #1056967, changes the semantics of Template.safe_substitute() to not raise a ValueError for dangling delimiters (the delimiter itself is returned).
2004-11-01 03:52:43 +00:00
eq = self.assertEqual
raises = self.assertRaises
Fix small bugs in Template code. * The parameterization of "delimiter" was incomplete. * safe_substitute's code for braced delimiters should only be executed when braced is not None. * Invalid pattern group names now raise a ValueError. Formerly, the convert code would fall off the end and improperly return None. Beefed-up tests. * Test delimiter override for all paths in substitute and safe_substitute. * Alter unittest invocation to match other modules (now it itemizes the tests as they are run).
2004-09-14 02:34:08 +00:00
class AmpersandTemplate(Template):
delimiter = '&'
s = AmpersandTemplate('this &gift is for &{who} &&')
SF patch #1056967, changes the semantics of Template.safe_substitute() to not raise a ValueError for dangling delimiters (the delimiter itself is returned).
2004-11-01 03:52:43 +00:00
eq(s.substitute(gift='bud', who='you'), 'this bud is for you &')
raises(KeyError, s.substitute)
eq(s.safe_substitute(gift='bud', who='you'), 'this bud is for you &')
eq(s.safe_substitute(), 'this &gift is for &{who} &')
Fix small bugs in Template code. * The parameterization of "delimiter" was incomplete. * safe_substitute's code for braced delimiters should only be executed when braced is not None. * Invalid pattern group names now raise a ValueError. Formerly, the convert code would fall off the end and improperly return None. Beefed-up tests. * Test delimiter override for all paths in substitute and safe_substitute. * Alter unittest invocation to match other modules (now it itemizes the tests as they are run).
2004-09-14 02:34:08 +00:00
s = AmpersandTemplate('this &gift is for &{who} &')
SF patch #1056967, changes the semantics of Template.safe_substitute() to not raise a ValueError for dangling delimiters (the delimiter itself is returned).
2004-11-01 03:52:43 +00:00
raises(ValueError, s.substitute, dict(gift='bud', who='you'))
eq(s.safe_substitute(), 'this &gift is for &{who} &')
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
def test_main():
from test import test_support
Fix small bugs in Template code. * The parameterization of "delimiter" was incomplete. * safe_substitute's code for braced delimiters should only be executed when braced is not None. * Invalid pattern group names now raise a ValueError. Formerly, the convert code would fall off the end and improperly return None. Beefed-up tests. * Test delimiter override for all paths in substitute and safe_substitute. * Alter unittest invocation to match other modules (now it itemizes the tests as they are run).
2004-09-14 02:34:08 +00:00
test_classes = [TestTemplate,]
test_support.run_unittest(*test_classes)
PEP 292 classes Template and SafeTemplate are added to the string module. This patch includes test cases and documentation updates, as well as NEWS file updates. This patch also updates the sre modules so that they don't import the string module, breaking direct circular imports.
2004-08-25 02:22:30 +00:00
if __name__ == '__main__':
Fix small bugs in Template code. * The parameterization of "delimiter" was incomplete. * safe_substitute's code for braced delimiters should only be executed when braced is not None. * Invalid pattern group names now raise a ValueError. Formerly, the convert code would fall off the end and improperly return None. Beefed-up tests. * Test delimiter override for all paths in substitute and safe_substitute. * Alter unittest invocation to match other modules (now it itemizes the tests as they are run).
2004-09-14 02:34:08 +00:00
test_main()
Reference in a new issue Copy permalink