python
diff --git a/Diff for: ‎Doc/library/hashlib.rst
+4 b/Diff for: ‎Doc/library/hashlib.rst
+4
diff --git a/Diff for: ‎Lib/distutils/sysconfig.py
+6-1 b/Diff for: ‎Lib/distutils/sysconfig.py
+6-1
diff --git a/Diff for: ‎Lib/hashlib.py
+3 b/Diff for: ‎Lib/hashlib.py
+3
diff --git a/Diff for: ‎Lib/test/regrtest.py
+8 b/Diff for: ‎Lib/test/regrtest.py
+8
diff --git a/Diff for: ‎Lib/test/test_import.py
+13-1 b/Diff for: ‎Lib/test/test_import.py
+13-1
diff --git a/Diff for: ‎Lib/test/test_int_literal.py
+2-2 b/Diff for: ‎Lib/test/test_int_literal.py
+2-2
diff --git a/Diff for: ‎Lib/test/test_nis.py
+6-4 b/Diff for: ‎Lib/test/test_nis.py
+6-4
diff --git a/Diff for: ‎Lib/test/test_posix.py
+28 b/Diff for: ‎Lib/test/test_posix.py
+28
diff --git a/Diff for: ‎Lib/test/test_print.py
+1-13 b/Diff for: ‎Lib/test/test_print.py
+1-13
diff --git a/Diff for: ‎Lib/test/test_winsound.py
+19-17 b/Diff for: ‎Lib/test/test_winsound.py
+19-17
diff --git a/Diff for: ‎Lib/test/test_zlib.py
+7 b/Diff for: ‎Lib/test/test_zlib.py
+7
@@ -19,6 +19,10 @@ algorithm (defined in Internet :rfc:`1321`).  The terms "secure hash" and
 "message digest" are interchangeable.  Older algorithms were called message
 digests.  The modern term is secure hash.
 
+.. note::
+   If you want the adler32 or crc32 hash functions they are available in
+   the :mod:`zlib` module.
+
 .. warning::
 
    Some algorithms have known hash collision weaknesses, see the FAQ at the end.
 
@@ -23,14 +23,19 @@
 EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
 
 # Path to the base directory of the project. On Windows the binary may
-# live in project/PCBuild9
+# live in project/PCBuild9.  If we're dealing with an x64 Windows build,
+# it'll live in project/PCbuild/amd64.
 project_base = os.path.dirname(os.path.abspath(sys.executable))
 if os.name == "nt" and "pcbuild" in project_base[-8:].lower():
     project_base = os.path.abspath(os.path.join(project_base, os.path.pardir))
 # PC/VS7.1
 if os.name == "nt" and "\\pc\\v" in project_base[-10:].lower():
     project_base = os.path.abspath(os.path.join(project_base, os.path.pardir,
                                                 os.path.pardir))
+# PC/AMD64
+if os.name == "nt" and "\\pcbuild\\amd64" in project_base[-14:].lower():
+    project_base = os.path.abspath(os.path.join(project_base, os.path.pardir,
+                                                os.path.pardir))
 
 # python_build: (Boolean) if true, we're either building Python or
 # building an extension with an un-installed Python, so we use
 
@@ -18,6 +18,9 @@
 More algorithms may be available on your platform but the above are
 guaranteed to exist.
 
+NOTE: If you want the adler32 or crc32 hash functions they are available in
+the zlib module.
+
 Choose your hash function wisely.  Some have known collision weaknesses.
 sha384 and sha512 will be slow on 32 bit platforms.
 
 
@@ -1157,6 +1157,14 @@ def __init__(self):
             if sys.platform != 'sunos5':
                 self.expected.add('test_nis')
 
+            # TODO: This is a hack to raise TestSkipped if -3 is not enabled.
+            # Instead of relying on callable to have a warning, we should expose
+            # the -3 flag to Python code somehow
+            with test_support.catch_warning() as w:
+                callable(int)
+                if w.message is None:
+                    self.expected.add('test_py3kwarn')
+
             self.valid = True
 
     def isvalid(self):
 
@@ -255,8 +255,20 @@ def test_trailing_slash(self):
         self.assertEqual(mod.testdata, 'test_trailing_slash')
         unload("test_trailing_slash")
 
+class RelativeImport(unittest.TestCase):
+    def tearDown(self):
+        try:
+            del sys.modules["test.relimport"]
+        except:
+            pass
+
+    def test_relimport_star(self):
+        # This will import * from .test_import.
+        from . import relimport
+        self.assertTrue(hasattr(relimport, "RelativeImport"))
+
 def test_main(verbose=None):
-    run_unittest(ImportTest, PathsTests)
+    run_unittest(ImportTest, PathsTests, RelativeImport)
 
 if __name__ == '__main__':
     test_main()
@@ -6,7 +6,7 @@
 import unittest
 from test import test_support
 
-class TextHexOctBin(unittest.TestCase):
+class TestHexOctBin(unittest.TestCase):
 
     def test_hex_baseline(self):
         # A few upper/lowercase tests
@@ -141,7 +141,7 @@ def test_bin_unsigned(self):
         self.assertEqual(-0b1111111111111111111111111111111111111111111111111111111111111111, -18446744073709551615)
 
 def test_main():
-    test_support.run_unittest(TextHexOctBin)
+    test_support.run_unittest(TestHexOctBin)
 
 if __name__ == "__main__":
     test_main()
@@ -1,4 +1,4 @@
-from test.test_support import verbose, run_unittest
+from test import test_support
 import unittest
 import nis
 
@@ -8,8 +8,10 @@ def test_maps(self):
             maps = nis.maps()
         except nis.error as msg:
             # NIS is probably not active, so this test isn't useful
-            if verbose:
-                self.fail("(failing because of verbose mode) %s" % msg)
+            if test_support.verbose:
+                print("Test Skipped:", msg)
+            # Can't raise TestSkipped as regrtest only recognizes the exception
+            #   import time.
             return
         try:
             # On some systems, this map is only accessible to the
@@ -35,7 +37,7 @@ def test_maps(self):
                 break
 
 def test_main():
-    run_unittest(NisTests)
+    test_support.run_unittest(NisTests)
 
 if __name__ == '__main__':
     test_main()
@@ -9,6 +9,7 @@
 
 import time
 import os
+import pwd
 import unittest
 import warnings
 warnings.filterwarnings('ignore', '.* potential security risk .*',
@@ -141,6 +142,33 @@ def test_stat(self):
         if hasattr(posix, 'stat'):
             self.assert_(posix.stat(test_support.TESTFN))
 
+    if hasattr(posix, 'chown'):
+        def test_chown(self):
+            # raise an OSError if the file does not exist
+            os.unlink(test_support.TESTFN)
+            self.assertRaises(OSError, posix.chown, test_support.TESTFN, -1, -1)
+
+            # re-create the file
+            open(test_support.TESTFN, 'w').close()
+            if os.getuid() == 0:
+                try:
+                    # Many linux distros have a nfsnobody user as MAX_UID-2
+                    # that makes a good test case for signedness issues.
+                    #   http://bugs.python.org/issue1747858
+                    # This part of the test only runs when run as root.
+                    # Only scary people run their tests as root.
+                    ent = pwd.getpwnam('nfsnobody')
+                    posix.chown(test_support.TESTFN, ent.pw_uid, ent.pw_gid)
+                except KeyError:
+                    pass
+            else:
+                # non-root cannot chown to root, raises OSError
+                self.assertRaises(OSError, posix.chown,
+                                  test_support.TESTFN, 0, 0)
+
+            # test a successful chown call
+            posix.chown(test_support.TESTFN, os.getuid(), os.getgid())
+
     def test_chdir(self):
         if hasattr(posix, 'chdir'):
             posix.chdir(os.curdir)
 
@@ -12,8 +12,6 @@
     # 2.x
     from StringIO import StringIO
 
-from contextlib import contextmanager
-
 NotDefined = object()
 
 # A dispatch table all 8 combinations of providing
@@ -40,15 +38,6 @@
      lambda args, sep, end, file: print(sep=sep, end=end, file=file, *args),
     }
 
-@contextmanager
-def stdout_redirected(new_stdout):
-    save_stdout = sys.stdout
-    sys.stdout = new_stdout
-    try:
-        yield None
-    finally:
-        sys.stdout = save_stdout
-
 # Class used to test __str__ and print
 class ClassWith__str__:
     def __init__(self, x):
@@ -69,8 +58,7 @@ def check(self, expected, args,
                        end is not NotDefined,
                        file is not NotDefined)]
 
-        t = StringIO()
-        with stdout_redirected(t):
+        with test_support.captured_stdout() as t:
             fn(args, sep, end, file)
 
         self.assertEqual(t.getvalue(), expected)
 
@@ -23,25 +23,27 @@ def test_errors(self):
         self.assertRaises(ValueError, winsound.Beep, 32768, 75)
 
     def test_extremes(self):
-        if _have_soundcard():
-            winsound.Beep(37, 75)
-            winsound.Beep(32767, 75)
-        else:
-            # The behaviour of winsound.Beep() seems to differ between
-            # different versions of Windows when there's either a) no
-            # sound card entirely, b) legacy beep driver has been disabled,
-            # or c) the legacy beep driver has been uninstalled.  Sometimes
-            # RuntimeErrors are raised, sometimes they're not.  Meh.
-            try:
-                winsound.Beep(37, 75)
-                winsound.Beep(32767, 75)
-            except RuntimeError:
-                pass
+        self._beep(37, 75)
+        self._beep(32767, 75)
 
     def test_increasingfrequency(self):
-        if _have_soundcard():
-            for i in range(100, 2000, 100):
-                winsound.Beep(i, 75)
+        for i in xrange(100, 2000, 100):
+            self._beep(i, 75)
+
+    def _beep(self, *args):
+        # these tests used to use _have_soundcard(), but it's quite
+        # possible to have a soundcard, and yet have the beep driver
+        # disabled. So basically, we have no way of knowing whether
+        # a beep should be produced or not, so currently if these
+        # tests fail we're ignoring them
+        #
+        # XXX the right fix for this is to define something like
+        # _have_enabled_beep_driver() and use that instead of the
+        # try/except below
+        try:
+            winsound.Beep(*args)
+        except RuntimeError:
+            pass
 
 class MessageBeepTest(unittest.TestCase):
 
 
@@ -1,6 +1,7 @@
 import unittest
 from test import test_support
 import zlib
+import binascii
 import random
 
 
@@ -46,6 +47,12 @@ def test_crc32_adler32_unsigned(self):
         self.assertEqual(zlib.adler32(foo+foo), 3573550353)
         self.assertEqual(zlib.adler32('spam'), 72286642)
 
+    def test_same_as_binascii_crc32(self):
+        foo = 'abcdefghijklmnop'
+        crc = -1808088941
+        self.assertEqual(binascii.crc32(foo), crc)
+        self.assertEqual(zlib.crc32(foo), crc)
+        self.assertEqual(binascii.crc32('spam'), zlib.crc32('spam'))