Merge 3.5.

1 files changed, 32 insertions, 30 deletions

diff --git a/Lib/test/test_string.py b/Lib/test/test_string.py
index faefb0d..70439f8 100644
--- a/Lib/test/test_string.py
+++ b/Lib/test/test_string.py
@@ -1,4 +1,6 @@
-import unittest, string
+import unittest
+import string
+from string import Template
 
 
 class ModuleTest(unittest.TestCase):
@@ -205,14 +207,14 @@ class Mapping:
 
 class TestTemplate(unittest.TestCase):
     def test_regular_templates(self):
-        s = string.Template('$who likes to eat a bag of $what worth $$100')
+        s = Template('$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')
         self.assertRaises(KeyError, s.substitute, dict(who='tim'))
-        self.assertRaises(TypeError, string.Template.substitute)
+        self.assertRaises(TypeError, Template.substitute)
 
     def test_regular_templates_with_braces(self):
-        s = string.Template('$who likes ${what} for ${meal}')
+        s = Template('$who likes ${what} for ${meal}')
         d = dict(who='tim', what='ham', meal='dinner')
         self.assertEqual(s.substitute(d), 'tim likes ham for dinner')
         self.assertRaises(KeyError, s.substitute,
@@ -220,38 +222,38 @@ class TestTemplate(unittest.TestCase):
 
     def test_escapes(self):
         eq = self.assertEqual
-        s = string.Template('$who likes to eat a bag of $$what worth $$100')
+        s = Template('$who likes to eat a bag of $$what worth $$100')
         eq(s.substitute(dict(who='tim', what='ham')),
            'tim likes to eat a bag of $what worth $100')
-        s = string.Template('$who likes $$')
+        s = Template('$who likes $$')
         eq(s.substitute(dict(who='tim', what='ham')), 'tim likes $')
 
     def test_percents(self):
         eq = self.assertEqual
-        s = string.Template('%(foo)s $foo ${foo}')
+        s = Template('%(foo)s $foo ${foo}')
         d = dict(foo='baz')
         eq(s.substitute(d), '%(foo)s baz baz')
         eq(s.safe_substitute(d), '%(foo)s baz baz')
 
     def test_stringification(self):
         eq = self.assertEqual
-        s = string.Template('tim has eaten $count bags of ham today')
+        s = Template('tim has eaten $count bags of ham today')
         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 = string.Template('tim has eaten ${count} 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')
 
     def test_tupleargs(self):
         eq = self.assertEqual
-        s = string.Template('$who ate ${meal}')
+        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')")
 
     def test_SafeTemplate(self):
         eq = self.assertEqual
-        s = string.Template('$who likes ${what} for ${meal}')
+        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')),
@@ -263,15 +265,15 @@ class TestTemplate(unittest.TestCase):
 
     def test_invalid_placeholders(self):
         raises = self.assertRaises
-        s = string.Template('$who likes $')
+        s = Template('$who likes $')
         raises(ValueError, s.substitute, dict(who='tim'))
-        s = string.Template('$who likes ${what)')
+        s = Template('$who likes ${what)')
         raises(ValueError, s.substitute, dict(who='tim'))
-        s = string.Template('$who likes $100')
+        s = Template('$who likes $100')
         raises(ValueError, s.substitute, dict(who='tim'))
 
     def test_idpattern_override(self):
-        class PathPattern(string.Template):
+        class PathPattern(Template):
             idpattern = r'[_a-z][._a-z0-9]*'
         m = Mapping()
         m.bag = Bag()
@@ -282,7 +284,7 @@ class TestTemplate(unittest.TestCase):
         self.assertEqual(s.substitute(m), 'tim likes to eat a bag of ham')
 
     def test_pattern_override(self):
-        class MyPattern(string.Template):
+        class MyPattern(Template):
             pattern = r"""
             (?P<escaped>@{2})                   |
             @(?P<named>[_a-z][._a-z0-9]*)       |
@@ -297,7 +299,7 @@ class TestTemplate(unittest.TestCase):
         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')
 
-        class BadPattern(string.Template):
+        class BadPattern(Template):
             pattern = r"""
             (?P<badname>.*)                     |
             (?P<escaped>@{2})                   |
@@ -310,7 +312,7 @@ class TestTemplate(unittest.TestCase):
         self.assertRaises(ValueError, s.safe_substitute, {})
 
     def test_braced_override(self):
-        class MyTemplate(string.Template):
+        class MyTemplate(Template):
             pattern = r"""
             \$(?:
               (?P<escaped>$)                     |
@@ -327,7 +329,7 @@ class TestTemplate(unittest.TestCase):
         self.assertEqual(val, 'PyCon in Cleveland')
 
     def test_braced_override_safe(self):
-        class MyTemplate(string.Template):
+        class MyTemplate(Template):
             pattern = r"""
             \$(?:
               (?P<escaped>$)                     |
@@ -349,7 +351,7 @@ class TestTemplate(unittest.TestCase):
         # pattern can't trigger (always has at least '$')
         # So we craft a pattern that is always invalid
         # with no leading data.
-        class MyTemplate(string.Template):
+        class MyTemplate(Template):
             pattern = r"""
               (?P<invalid>) |
               unreachable(
@@ -364,37 +366,37 @@ class TestTemplate(unittest.TestCase):
         self.assertIn('line 1, col 1', str(err.exception))
 
     def test_unicode_values(self):
-        s = string.Template('$who likes $what')
+        s = Template('$who likes $what')
         d = dict(who='t\xffm', what='f\xfe\fed')
         self.assertEqual(s.substitute(d), 't\xffm likes f\xfe\x0ced')
 
     def test_keyword_arguments(self):
         eq = self.assertEqual
-        s = string.Template('$who likes $what')
+        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 = string.Template('the mapping is $mapping')
+        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')
 
-        s = string.Template('the self is $self')
+        s = Template('the self is $self')
         eq(s.substitute(self='bozo'), 'the self is bozo')
 
     def test_keyword_arguments_safe(self):
         eq = self.assertEqual
         raises = self.assertRaises
-        s = string.Template('$who likes $what')
+        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 = string.Template('the mapping is $mapping')
+        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'),
@@ -403,13 +405,13 @@ class TestTemplate(unittest.TestCase):
         raises(TypeError, s.substitute, d, {})
         raises(TypeError, s.safe_substitute, d, {})
 
-        s = string.Template('the self is $self')
+        s = Template('the self is $self')
         eq(s.safe_substitute(self='bozo'), 'the self is bozo')
 
     def test_delimiter_override(self):
         eq = self.assertEqual
         raises = self.assertRaises
-        class AmpersandTemplate(string.Template):
+        class AmpersandTemplate(Template):
             delimiter = '&'
         s = AmpersandTemplate('this &gift is for &{who} &&')
         eq(s.substitute(gift='bud', who='you'), 'this bud is for you &')
@@ -420,12 +422,12 @@ class TestTemplate(unittest.TestCase):
         raises(ValueError, s.substitute, dict(gift='bud', who='you'))
         eq(s.safe_substitute(), 'this &gift is for &{who} &')
 
-        class PieDelims(string.Template):
+        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')
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     unittest.main()