Merged revisions 84470-84471,84566-84567,84759 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/branches/py3k

........
  r84470 | florent.xicluna | 2010-09-03 22:00:37 +0200 (ven., 03 sept. 2010) | 1 line

  Strengthen BytesWarning tests.
........
  r84471 | florent.xicluna | 2010-09-03 22:23:40 +0200 (ven., 03 sept. 2010) | 1 line

  Typo
........
  r84566 | florent.xicluna | 2010-09-06 22:27:15 +0200 (lun., 06 sept. 2010) | 1 line

  typo
........
  r84567 | florent.xicluna | 2010-09-06 22:27:55 +0200 (lun., 06 sept. 2010) | 1 line

  typo
........
  r84759 | florent.xicluna | 2010-09-13 04:28:18 +0200 (lun., 13 sept. 2010) | 1 line

  Reenable test_ucs4 and remove some duplicated lines.
........

diff --git a/Doc/reference/simple_stmts.rst b/Doc/reference/simple_stmts.rst
index b9cdd91db793b45d1fa39666307db13255a70684..c0d818241bd7e68298f34b885880e1e73749a5f9 100644 (file)
--- a/Doc/reference/simple_stmts.rst
+++ b/Doc/reference/simple_stmts.rst
@@ -836,7 +836,7 @@ leading dot means the current package where the module making the import
 exists. Two dots means up one package level. Three dots is up two levels, etc.
 So if you execute ``from . import mod`` from a module in the ``pkg`` package
 then you will end up importing ``pkg.mod``. If you execute ``from ..subpkg2
-imprt mod`` from within ``pkg.subpkg1`` you will import ``pkg.subpkg2.mod``.
+import mod`` from within ``pkg.subpkg1`` you will import ``pkg.subpkg2.mod``.
 The specification for relative imports is contained within :pep:`328`.
 
 :func:`importlib.import_module` is provided to support applications that

diff --git a/Lib/string.py b/Lib/string.py
index 5e13d15338c63957abceacbe5ac58541444bbb30..9c0ebe1fd46f6ac73074e6e8dd72d7843e3d7d80 100644 (file)
--- a/Lib/string.py
+++ b/Lib/string.py
@@ -607,7 +607,7 @@ class Formatter(object):
             return str(value)
         elif conversion is None:
             return value
-        raise ValueError("Unknown converion specifier {0!s}".format(conversion))
+        raise ValueError("Unknown conversion specifier {0!s}".format(conversion))
 
 
     # returns an iterable that contains tuples of the form:

diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py
index 7cfe65be35eaab42fe4ca125da819d2f35f36473..56cbc35895c14cc3f0808af78822b16e01094577 100644 (file)
--- a/Lib/test/string_tests.py
+++ b/Lib/test/string_tests.py
@@ -1119,7 +1119,7 @@ class MixinStrUnicodeUserStringTest:
             format = '%%.%if' % prec
             value = 0.01
             for x in xrange(60):
-                value = value * 3.141592655 / 3.0 * 10.0
+                value = value * 3.14159265359 / 3.0 * 10.0
                 self.checkcall(format, "__mod__", value)
 
     def test_inplace_rewrites(self):

diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py
index 516d6d9782a8125e991b53229718a39cdc141208..d0f56625c8b712fa9022d30e0b4f35bd5634d8eb 100644 (file)
--- a/Lib/test/test_bytes.py
+++ b/Lib/test/test_bytes.py
@@ -9,14 +9,28 @@ import os
 import re
 import sys
 import copy
+import functools
 import pickle
 import tempfile
 import unittest
-import warnings
 import test.test_support
 import test.string_tests
 import test.buffer_tests
 
+
+if sys.flags.bytes_warning:
+    def check_bytes_warnings(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kw):
+            with test.test_support.check_warnings(('', BytesWarning)):
+                return func(*args, **kw)
+        return wrapper
+else:
+    # no-op
+    def check_bytes_warnings(func):
+        return func
+
+
 class Indexable:
     def __init__(self, value=0):
         self.value = value
@@ -26,12 +40,6 @@ class Indexable:
 
 class BaseBytesTest(unittest.TestCase):
 
-    def setUp(self):
-        self.warning_filters = warnings.filters[:]
-
-    def tearDown(self):
-        warnings.filters = self.warning_filters
-
     def test_basics(self):
         b = self.type2test()
         self.assertEqual(type(b), self.type2test)
@@ -120,8 +128,8 @@ class BaseBytesTest(unittest.TestCase):
         self.assertFalse(b3 <  b2)
         self.assertFalse(b3 <= b2)
 
+    @check_bytes_warnings
     def test_compare_to_str(self):
-        warnings.simplefilter('ignore', BytesWarning)
         # Byte comparisons with unicode should always fail!
         # Test this for all expected byte orders and Unicode character sizes
         self.assertEqual(self.type2test(b"\0a\0b\0c") == u"abc", False)
@@ -795,14 +803,8 @@ class AssortedBytesTest(unittest.TestCase):
     # Test various combinations of bytes and bytearray
     #
 
-    def setUp(self):
-        self.warning_filters = warnings.filters[:]
-
-    def tearDown(self):
-        warnings.filters = self.warning_filters
-
+    @check_bytes_warnings
     def test_repr_str(self):
-        warnings.simplefilter('ignore', BytesWarning)
         for f in str, repr:
             self.assertEqual(f(bytearray()), "bytearray(b'')")
             self.assertEqual(f(bytearray([0])), "bytearray(b'\\x00')")
@@ -853,8 +855,8 @@ class AssortedBytesTest(unittest.TestCase):
         b = bytearray(buf)
         self.assertEqual(b, bytearray(sample))
 
+    @check_bytes_warnings
     def test_to_str(self):
-        warnings.simplefilter('ignore', BytesWarning)
         self.assertEqual(str(b''), "b''")
         self.assertEqual(str(b'x'), "b'x'")
         self.assertEqual(str(b'\x80'), "b'\\x80'")

diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index 1151e867a4d667b470121e9ff3a6dcf3e12a8e76..b309704631b1beb2f31abe081d31534c84642095 100644 (file)
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -593,9 +593,9 @@ class UnicodeTest(
         )
 
         # UTF-8 specific decoding tests
-        self.assertEqual(unicode('\xf0\xa3\x91\x96', 'utf-8'), u'\U00023456' )
-        self.assertEqual(unicode('\xf0\x90\x80\x82', 'utf-8'), u'\U00010002' )
-        self.assertEqual(unicode('\xe2\x82\xac', 'utf-8'), u'\u20ac' )
+        self.assertEqual(unicode('\xf0\xa3\x91\x96', 'utf-8'), u'\U00023456')
+        self.assertEqual(unicode('\xf0\x90\x80\x82', 'utf-8'), u'\U00010002')
+        self.assertEqual(unicode('\xe2\x82\xac', 'utf-8'), u'\u20ac')
 
         # Other possible utf-8 test cases:
         # * strict decoding testing for all of the
@@ -1360,8 +1360,8 @@ class UnicodeTest(
             def __unicode__(self):
                 return u'__unicode__ overridden'
         u = U(u'xxx')
-        self.assertEquals("%s" % u, u'__unicode__ overridden')
-        self.assertEquals("{}".format(u), u'__unicode__ overridden')
+        self.assertEqual("%s" % u, u'__unicode__ overridden')
+        self.assertEqual("{}".format(u), u'__unicode__ overridden')
 
 
 def test_main():

diff --git a/Misc/pymemcompat.h b/Misc/pymemcompat.h
index 2757e3acddfb4037252df50233792a11eb93a378..a0fa33663fd876b10e8cd24dd7db29b4ed65e4b0 100644 (file)
--- a/Misc/pymemcompat.h
+++ b/Misc/pymemcompat.h
@@ -72,7 +72,7 @@
 
    It is possible to support both the 2.0 and 2.2 GC APIs, but it's
    not pretty and this comment block is too narrow to contain a
-   desciption of what's required... */
+   description of what's required... */
 
 #if PY_VERSION_HEX < 0x020200B1
 #define PyObject_GC_New         PyObject_New