mirror of
https://github.com/python/cpython.git
synced 2025-08-02 08:02:56 +00:00
Issue #18702: All skipped tests now reported as skipped.
This commit is contained in:
Serhiy Storchaka
parent
834856aca9
commit
7908068627
21 changed files with 908 additions and 883 deletions
|
|
@ -11,6 +11,7 @@ import operator
|
|||
import io
|
||||
import math
|
||||
import struct
|
||||
import sys
|
||||
import warnings
|
||||
|
||||
import array
|
||||
|
|
@ -993,9 +994,9 @@ class BaseTest:
|
|||
s = None
|
||||
self.assertRaises(ReferenceError, len, p)
|
||||
|
||||
@unittest.skipUnless(hasattr(sys, 'getrefcount'),
|
||||
'test needs sys.getrefcount()')
|
||||
def test_bug_782369(self):
|
||||
import sys
|
||||
if hasattr(sys, "getrefcount"):
|
||||
for i in range(10):
|
||||
b = array.array('B', range(64))
|
||||
rc = sys.getrefcount(10)
|
||||
|
|
|
|||
|
|
@ -39,11 +39,10 @@ class CompileallTests(unittest.TestCase):
|
|||
compare = struct.pack('<4sl', imp.get_magic(), mtime)
|
||||
return data, compare
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()')
|
||||
def recreation_check(self, metadata):
|
||||
"""Check that compileall recreates bytecode when the new metadata is
|
||||
used."""
|
||||
if not hasattr(os, 'stat'):
|
||||
return
|
||||
py_compile.compile(self.source_path)
|
||||
self.assertEqual(*self.data())
|
||||
with open(self.bc_path, 'rb') as file:
|
||||
|
|
|
|||
|
|
@ -896,14 +896,13 @@ Stonecutters Seafood and Chop House+ Lemont+ IL+ 12/19/02+ Week Back
|
|||
dialect = sniffer.sniff(self.sample9)
|
||||
self.assertTrue(dialect.doublequote)
|
||||
|
||||
if not hasattr(sys, "gettotalrefcount"):
|
||||
if support.verbose: print("*** skipping leakage tests ***")
|
||||
else:
|
||||
class NUL:
|
||||
def write(s, *args):
|
||||
pass
|
||||
writelines = write
|
||||
|
||||
@unittest.skipUnless(hasattr(sys, "gettotalrefcount"),
|
||||
'requires sys.gettotalrefcount()')
|
||||
class TestLeaks(unittest.TestCase):
|
||||
def test_create_read(self):
|
||||
delta = 0
|
||||
|
|
|
|||
|
|
@ -37,11 +37,9 @@ class DumbDBMTestCase(unittest.TestCase):
|
|||
self.read_helper(f)
|
||||
f.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
|
||||
@unittest.skipUnless(hasattr(os, 'chmod'), 'test needs os.chmod()')
|
||||
def test_dumbdbm_creation_mode(self):
|
||||
# On platforms without chmod, don't do anything.
|
||||
if not (hasattr(os, 'chmod') and hasattr(os, 'umask')):
|
||||
return
|
||||
|
||||
try:
|
||||
old_umask = os.umask(0o002)
|
||||
f = dumbdbm.open(_fname, 'c', 0o637)
|
||||
|
|
|
|||
|
|
@ -204,11 +204,10 @@ class TestReversed(unittest.TestCase, PickleTest):
|
|||
self.assertRaises(TypeError, reversed)
|
||||
self.assertRaises(TypeError, reversed, [], 'extra')
|
||||
|
||||
@unittest.skipUnless(hasattr(sys, 'getrefcount'), 'test needs sys.getrefcount()')
|
||||
def test_bug1229429(self):
|
||||
# this bug was never in reversed, it was in
|
||||
# PyObject_CallMethod, and reversed_new calls that sometimes.
|
||||
if not hasattr(sys, "getrefcount"):
|
||||
return
|
||||
def f():
|
||||
pass
|
||||
r = f.__reversed__ = object()
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ try:
|
|||
except ImportError:
|
||||
ssl = None
|
||||
|
||||
from unittest import TestCase
|
||||
from unittest import TestCase, skipUnless
|
||||
from test import support
|
||||
from test.support import HOST, HOSTv6
|
||||
threading = support.import_module('threading')
|
||||
|
|
@ -779,6 +779,7 @@ class TestFTPClass(TestCase):
|
|||
self.assertRaises(ftplib.Error, self.client.storlines, 'stor', f)
|
||||
|
||||
|
||||
@skipUnless(support.IPV6_ENABLED, "IPv6 not enabled")
|
||||
class TestIPv6Environment(TestCase):
|
||||
|
||||
def setUp(self):
|
||||
|
|
@ -819,6 +820,7 @@ class TestIPv6Environment(TestCase):
|
|||
retr()
|
||||
|
||||
|
||||
@skipUnless(ssl, "SSL not available")
|
||||
class TestTLS_FTPClassMixin(TestFTPClass):
|
||||
"""Repeat TestFTPClass tests starting the TLS layer for both control
|
||||
and data connections first.
|
||||
|
|
@ -834,6 +836,7 @@ class TestTLS_FTPClassMixin(TestFTPClass):
|
|||
self.client.prot_p()
|
||||
|
||||
|
||||
@skipUnless(ssl, "SSL not available")
|
||||
class TestTLS_FTPClass(TestCase):
|
||||
"""Specific TLS_FTP class tests."""
|
||||
|
||||
|
|
@ -1015,12 +1018,9 @@ class TestTimeouts(TestCase):
|
|||
|
||||
|
||||
def test_main():
|
||||
tests = [TestFTPClass, TestTimeouts]
|
||||
if support.IPV6_ENABLED:
|
||||
tests.append(TestIPv6Environment)
|
||||
|
||||
if ssl is not None:
|
||||
tests.extend([TestTLS_FTPClassMixin, TestTLS_FTPClass])
|
||||
tests = [TestFTPClass, TestTimeouts,
|
||||
TestIPv6Environment,
|
||||
TestTLS_FTPClassMixin, TestTLS_FTPClass]
|
||||
|
||||
thread_info = support.threading_setup()
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -868,10 +868,10 @@ class TestMaildir(TestMailbox, unittest.TestCase):
|
|||
for msg in self._box:
|
||||
pass
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
|
||||
@unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()')
|
||||
def test_file_permissions(self):
|
||||
# Verify that message files are created without execute permissions
|
||||
if not hasattr(os, "stat") or not hasattr(os, "umask"):
|
||||
return
|
||||
msg = mailbox.MaildirMessage(self._template % 0)
|
||||
orig_umask = os.umask(0)
|
||||
try:
|
||||
|
|
@ -882,12 +882,11 @@ class TestMaildir(TestMailbox, unittest.TestCase):
|
|||
mode = os.stat(path).st_mode
|
||||
self.assertFalse(mode & 0o111)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
|
||||
@unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()')
|
||||
def test_folder_file_perms(self):
|
||||
# From bug #3228, we want to verify that the file created inside a Maildir
|
||||
# subfolder isn't marked as executable.
|
||||
if not hasattr(os, "stat") or not hasattr(os, "umask"):
|
||||
return
|
||||
|
||||
orig_umask = os.umask(0)
|
||||
try:
|
||||
subfolder = self._box.add_folder('subfolder')
|
||||
|
|
@ -1097,11 +1096,12 @@ class TestMbox(_TestMboxMMDF, unittest.TestCase):
|
|||
|
||||
_factory = lambda self, path, factory=None: mailbox.mbox(path, factory)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()')
|
||||
@unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()')
|
||||
def test_file_perms(self):
|
||||
# From bug #3228, we want to verify that the mailbox file isn't executable,
|
||||
# even if the umask is set to something that would leave executable bits set.
|
||||
# We only run this test on platforms that support umask.
|
||||
if hasattr(os, 'umask') and hasattr(os, 'stat'):
|
||||
try:
|
||||
old_umask = os.umask(0o077)
|
||||
self._box.close()
|
||||
|
|
|
|||
|
|
@ -980,8 +980,7 @@ class MathTests(unittest.TestCase):
|
|||
# still fails this part of the test on some platforms. For now, we only
|
||||
# *run* test_exceptions() in verbose mode, so that this isn't normally
|
||||
# tested.
|
||||
|
||||
if verbose:
|
||||
@unittest.skipUnless(verbose, 'requires verbose mode')
|
||||
def test_exceptions(self):
|
||||
try:
|
||||
x = math.exp(-1000000000)
|
||||
|
|
|
|||
|
|
@ -314,9 +314,9 @@ class MmapTests(unittest.TestCase):
|
|||
mf.close()
|
||||
f.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(os, "stat"), "needs os.stat()")
|
||||
def test_entire_file(self):
|
||||
# test mapping of entire file by passing 0 for map length
|
||||
if hasattr(os, "stat"):
|
||||
f = open(TESTFN, "wb+")
|
||||
|
||||
f.write(2**16 * b'm') # Arbitrary character
|
||||
|
|
@ -329,11 +329,10 @@ class MmapTests(unittest.TestCase):
|
|||
mf.close()
|
||||
f.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(os, "stat"), "needs os.stat()")
|
||||
def test_length_0_offset(self):
|
||||
# Issue #10916: test mapping of remainder of file by passing 0 for
|
||||
# map length with an offset doesn't cause a segfault.
|
||||
if not hasattr(os, "stat"):
|
||||
self.skipTest("needs os.stat")
|
||||
# NOTE: allocation granularity is currently 65536 under Win64,
|
||||
# and therefore the minimum offset alignment.
|
||||
with open(TESTFN, "wb") as f:
|
||||
|
|
@ -343,12 +342,10 @@ class MmapTests(unittest.TestCase):
|
|||
with mmap.mmap(f.fileno(), 0, offset=65536, access=mmap.ACCESS_READ) as mf:
|
||||
self.assertRaises(IndexError, mf.__getitem__, 80000)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, "stat"), "needs os.stat()")
|
||||
def test_length_0_large_offset(self):
|
||||
# Issue #10959: test mapping of a file by passing 0 for
|
||||
# map length with a large offset doesn't cause a segfault.
|
||||
if not hasattr(os, "stat"):
|
||||
self.skipTest("needs os.stat")
|
||||
|
||||
with open(TESTFN, "wb") as f:
|
||||
f.write(115699 * b'm') # Arbitrary character
|
||||
|
||||
|
|
@ -560,9 +557,8 @@ class MmapTests(unittest.TestCase):
|
|||
return mmap.mmap.__new__(klass, -1, *args, **kwargs)
|
||||
anon_mmap(PAGESIZE)
|
||||
|
||||
@unittest.skipUnless(hasattr(mmap, 'PROT_READ'), "needs mmap.PROT_READ")
|
||||
def test_prot_readonly(self):
|
||||
if not hasattr(mmap, 'PROT_READ'):
|
||||
return
|
||||
mapsize = 10
|
||||
with open(TESTFN, "wb") as fp:
|
||||
fp.write(b"a"*mapsize)
|
||||
|
|
@ -616,7 +612,7 @@ class MmapTests(unittest.TestCase):
|
|||
self.assertEqual(m.read_byte(), b)
|
||||
m.close()
|
||||
|
||||
if os.name == 'nt':
|
||||
@unittest.skipUnless(os.name == 'nt', 'requires Windows')
|
||||
def test_tagname(self):
|
||||
data1 = b"0123456789"
|
||||
data2 = b"abcdefghij"
|
||||
|
|
@ -642,6 +638,7 @@ class MmapTests(unittest.TestCase):
|
|||
m2.close()
|
||||
m1.close()
|
||||
|
||||
@unittest.skipUnless(os.name == 'nt', 'requires Windows')
|
||||
def test_crasher_on_windows(self):
|
||||
# Should not crash (Issue 1733986)
|
||||
m = mmap.mmap(-1, 1000, tagname="foo")
|
||||
|
|
@ -667,6 +664,7 @@ class MmapTests(unittest.TestCase):
|
|||
pass
|
||||
m.close()
|
||||
|
||||
@unittest.skipUnless(os.name == 'nt', 'requires Windows')
|
||||
def test_invalid_descriptor(self):
|
||||
# socket file descriptors are valid, but out of range
|
||||
# for _get_osfhandle, causing a crash when validating the
|
||||
|
|
|
|||
|
|
@ -6,10 +6,12 @@ import unittest
|
|||
import functools
|
||||
import contextlib
|
||||
from test import support
|
||||
from nntplib import NNTP, GroupInfo, _have_ssl
|
||||
from nntplib import NNTP, GroupInfo
|
||||
import nntplib
|
||||
if _have_ssl:
|
||||
try:
|
||||
import ssl
|
||||
except ImportError:
|
||||
ssl = None
|
||||
|
||||
TIMEOUT = 30
|
||||
|
||||
|
|
@ -199,7 +201,7 @@ class NetworkedNNTPTestsMixin:
|
|||
resp, caps = self.server.capabilities()
|
||||
_check_caps(caps)
|
||||
|
||||
if _have_ssl:
|
||||
@unittest.skipUnless(ssl, 'requires SSL support')
|
||||
def test_starttls(self):
|
||||
file = self.server.file
|
||||
sock = self.server.sock
|
||||
|
|
@ -300,8 +302,7 @@ class NetworkedNNTPTests(NetworkedNNTPTestsMixin, unittest.TestCase):
|
|||
if cls.server is not None:
|
||||
cls.server.quit()
|
||||
|
||||
|
||||
if _have_ssl:
|
||||
@unittest.skipUnless(ssl, 'requires SSL support')
|
||||
class NetworkedNNTP_SSLTests(NetworkedNNTPTests):
|
||||
|
||||
# Technical limits for this public NNTP server (see http://www.aioe.org):
|
||||
|
|
@ -312,7 +313,7 @@ if _have_ssl:
|
|||
GROUP_NAME = 'comp.lang.python'
|
||||
GROUP_PAT = 'comp.lang.*'
|
||||
|
||||
NNTP_CLASS = nntplib.NNTP_SSL
|
||||
NNTP_CLASS = getattr(nntplib, 'NNTP_SSL', None)
|
||||
|
||||
# Disabled as it produces too much data
|
||||
test_list = None
|
||||
|
|
@ -1407,12 +1408,13 @@ class MiscTests(unittest.TestCase):
|
|||
gives(2000, 6, 23, "000623", "000000")
|
||||
gives(2010, 6, 5, "100605", "000000")
|
||||
|
||||
@unittest.skipUnless(ssl, 'requires SSL support')
|
||||
def test_ssl_support(self):
|
||||
self.assertTrue(hasattr(nntplib, 'NNTP_SSL'))
|
||||
|
||||
def test_main():
|
||||
tests = [MiscTests, NNTPv1Tests, NNTPv2Tests, CapsAfterLoginNNTPv2Tests,
|
||||
SendReaderNNTPv2Tests, NetworkedNNTPTests]
|
||||
if _have_ssl:
|
||||
tests.append(NetworkedNNTP_SSLTests)
|
||||
SendReaderNNTPv2Tests, NetworkedNNTPTests, NetworkedNNTP_SSLTests]
|
||||
support.run_unittest(*tests)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -178,10 +178,8 @@ class StatAttributeTests(unittest.TestCase):
|
|||
os.unlink(self.fname)
|
||||
os.rmdir(support.TESTFN)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()')
|
||||
def check_stat_attributes(self, fname):
|
||||
if not hasattr(os, "stat"):
|
||||
return
|
||||
|
||||
result = os.stat(fname)
|
||||
|
||||
# Make sure direct access works
|
||||
|
|
@ -258,10 +256,8 @@ class StatAttributeTests(unittest.TestCase):
|
|||
warnings.simplefilter("ignore", DeprecationWarning)
|
||||
self.check_stat_attributes(fname)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'statvfs'), 'test needs os.statvfs()')
|
||||
def test_statvfs_attributes(self):
|
||||
if not hasattr(os, "statvfs"):
|
||||
return
|
||||
|
||||
try:
|
||||
result = os.statvfs(self.fname)
|
||||
except OSError as e:
|
||||
|
|
@ -450,10 +446,10 @@ class StatAttributeTests(unittest.TestCase):
|
|||
os.close(dirfd)
|
||||
self._test_utime_subsecond(set_time)
|
||||
|
||||
# Restrict test to Win32, since there is no guarantee other
|
||||
# Restrict tests to Win32, since there is no guarantee other
|
||||
# systems support centiseconds
|
||||
if sys.platform == 'win32':
|
||||
def get_file_system(path):
|
||||
if sys.platform == 'win32':
|
||||
root = os.path.splitdrive(os.path.abspath(path))[0] + '\\'
|
||||
import ctypes
|
||||
kernel32 = ctypes.windll.kernel32
|
||||
|
|
@ -461,17 +457,23 @@ class StatAttributeTests(unittest.TestCase):
|
|||
if kernel32.GetVolumeInformationW(root, None, 0, None, None, None, buf, len(buf)):
|
||||
return buf.value
|
||||
|
||||
if get_file_system(support.TESTFN) == "NTFS":
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
@unittest.skipUnless(get_file_system(support.TESTFN) == "NTFS",
|
||||
"requires NTFS")
|
||||
def test_1565150(self):
|
||||
t1 = 1159195039.25
|
||||
os.utime(self.fname, (t1, t1))
|
||||
self.assertEqual(os.stat(self.fname).st_mtime, t1)
|
||||
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
@unittest.skipUnless(get_file_system(support.TESTFN) == "NTFS",
|
||||
"requires NTFS")
|
||||
def test_large_time(self):
|
||||
t1 = 5000000000 # some day in 2128
|
||||
os.utime(self.fname, (t1, t1))
|
||||
self.assertEqual(os.stat(self.fname).st_mtime, t1)
|
||||
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
def test_1686475(self):
|
||||
# Verify that an open file can be stat'ed
|
||||
try:
|
||||
|
|
@ -481,6 +483,7 @@ class StatAttributeTests(unittest.TestCase):
|
|||
return
|
||||
self.fail("Could not stat pagefile.sys")
|
||||
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
@unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
|
||||
def test_15261(self):
|
||||
# Verify that stat'ing a closed fd does not cause crash
|
||||
|
|
@ -1127,6 +1130,7 @@ class ExecTests(unittest.TestCase):
|
|||
self._test_internal_execvpe(bytes)
|
||||
|
||||
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
class Win32ErrorTests(unittest.TestCase):
|
||||
def test_rename(self):
|
||||
self.assertRaises(WindowsError, os.rename, support.TESTFN, support.TESTFN+".bak")
|
||||
|
|
@ -1173,12 +1177,12 @@ class TestInvalidFD(unittest.TestCase):
|
|||
self.fail("%r didn't raise a OSError with a bad file descriptor"
|
||||
% f)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'isatty'), 'test needs os.isatty()')
|
||||
def test_isatty(self):
|
||||
if hasattr(os, "isatty"):
|
||||
self.assertEqual(os.isatty(support.make_bad_fd()), False)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'closerange'), 'test needs os.closerange()')
|
||||
def test_closerange(self):
|
||||
if hasattr(os, "closerange"):
|
||||
fd = support.make_bad_fd()
|
||||
# Make sure none of the descriptors we are about to close are
|
||||
# currently valid (issue 6542).
|
||||
|
|
@ -1193,42 +1197,42 @@ class TestInvalidFD(unittest.TestCase):
|
|||
"Unable to acquire a range of invalid file descriptors")
|
||||
self.assertEqual(os.closerange(fd, fd + i-1), None)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'dup2'), 'test needs os.dup2()')
|
||||
def test_dup2(self):
|
||||
if hasattr(os, "dup2"):
|
||||
self.check(os.dup2, 20)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'fchmod'), 'test needs os.fchmod()')
|
||||
def test_fchmod(self):
|
||||
if hasattr(os, "fchmod"):
|
||||
self.check(os.fchmod, 0)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'fchown'), 'test needs os.fchown()')
|
||||
def test_fchown(self):
|
||||
if hasattr(os, "fchown"):
|
||||
self.check(os.fchown, -1, -1)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'fpathconf'), 'test needs os.fpathconf()')
|
||||
def test_fpathconf(self):
|
||||
if hasattr(os, "fpathconf"):
|
||||
self.check(os.pathconf, "PC_NAME_MAX")
|
||||
self.check(os.fpathconf, "PC_NAME_MAX")
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'ftruncate'), 'test needs os.ftruncate()')
|
||||
def test_ftruncate(self):
|
||||
if hasattr(os, "ftruncate"):
|
||||
self.check(os.truncate, 0)
|
||||
self.check(os.ftruncate, 0)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'lseek'), 'test needs os.lseek()')
|
||||
def test_lseek(self):
|
||||
if hasattr(os, "lseek"):
|
||||
self.check(os.lseek, 0, 0)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'read'), 'test needs os.read()')
|
||||
def test_read(self):
|
||||
if hasattr(os, "read"):
|
||||
self.check(os.read, 1)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'tcsetpgrp'), 'test needs os.tcsetpgrp()')
|
||||
def test_tcsetpgrpt(self):
|
||||
if hasattr(os, "tcsetpgrp"):
|
||||
self.check(os.tcsetpgrp, 0)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, 'write'), 'test needs os.write()')
|
||||
def test_write(self):
|
||||
if hasattr(os, "write"):
|
||||
self.check(os.write, b" ")
|
||||
|
||||
|
||||
|
|
@ -1269,63 +1273,47 @@ class LinkTests(unittest.TestCase):
|
|||
self.file2 = self.file1 + "2"
|
||||
self._test_link(self.file1, self.file2)
|
||||
|
||||
if sys.platform != 'win32':
|
||||
class Win32ErrorTests(unittest.TestCase):
|
||||
pass
|
||||
|
||||
@unittest.skipIf(sys.platform == "win32", "Posix specific tests")
|
||||
class PosixUidGidTests(unittest.TestCase):
|
||||
if hasattr(os, 'setuid'):
|
||||
@unittest.skipUnless(hasattr(os, 'setuid'), 'test needs os.setuid()')
|
||||
def test_setuid(self):
|
||||
if os.getuid() != 0:
|
||||
self.assertRaises(os.error, os.setuid, 0)
|
||||
self.assertRaises(OverflowError, os.setuid, 1<<32)
|
||||
|
||||
if hasattr(os, 'setgid'):
|
||||
@unittest.skipUnless(hasattr(os, 'setgid'), 'test needs os.setgid()')
|
||||
def test_setgid(self):
|
||||
if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
|
||||
self.assertRaises(os.error, os.setgid, 0)
|
||||
self.assertRaises(OverflowError, os.setgid, 1<<32)
|
||||
|
||||
if hasattr(os, 'seteuid'):
|
||||
@unittest.skipUnless(hasattr(os, 'seteuid'), 'test needs os.seteuid()')
|
||||
def test_seteuid(self):
|
||||
if os.getuid() != 0:
|
||||
self.assertRaises(os.error, os.seteuid, 0)
|
||||
self.assertRaises(OverflowError, os.seteuid, 1<<32)
|
||||
|
||||
if hasattr(os, 'setegid'):
|
||||
@unittest.skipUnless(hasattr(os, 'setegid'), 'test needs os.setegid()')
|
||||
def test_setegid(self):
|
||||
if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
|
||||
self.assertRaises(os.error, os.setegid, 0)
|
||||
self.assertRaises(OverflowError, os.setegid, 1<<32)
|
||||
|
||||
if hasattr(os, 'setreuid'):
|
||||
@unittest.skipUnless(hasattr(os, 'setreuid'), 'test needs os.setreuid()')
|
||||
def test_setreuid(self):
|
||||
if os.getuid() != 0:
|
||||
self.assertRaises(os.error, os.setreuid, 0, 0)
|
||||
self.assertRaises(OverflowError, os.setreuid, 1<<32, 0)
|
||||
self.assertRaises(OverflowError, os.setreuid, 0, 1<<32)
|
||||
|
||||
def test_setreuid_neg1(self):
|
||||
# Needs to accept -1. We run this in a subprocess to avoid
|
||||
# altering the test runner's process state (issue8045).
|
||||
subprocess.check_call([
|
||||
sys.executable, '-c',
|
||||
'import os,sys;os.setreuid(-1,-1);sys.exit(0)'])
|
||||
|
||||
if hasattr(os, 'setregid'):
|
||||
@unittest.skipUnless(hasattr(os, 'setregid'), 'test needs os.setregid()')
|
||||
def test_setregid(self):
|
||||
if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
|
||||
self.assertRaises(os.error, os.setregid, 0, 0)
|
||||
self.assertRaises(OverflowError, os.setregid, 1<<32, 0)
|
||||
self.assertRaises(OverflowError, os.setregid, 0, 1<<32)
|
||||
|
||||
def test_setregid_neg1(self):
|
||||
# Needs to accept -1. We run this in a subprocess to avoid
|
||||
# altering the test runner's process state (issue8045).
|
||||
subprocess.check_call([
|
||||
sys.executable, '-c',
|
||||
'import os,sys;os.setregid(-1,-1);sys.exit(0)'])
|
||||
|
||||
@unittest.skipIf(sys.platform == "win32", "Posix specific tests")
|
||||
class Pep383Tests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
if support.TESTFN_UNENCODABLE:
|
||||
|
|
@ -1396,11 +1384,6 @@ if sys.platform != 'win32':
|
|||
def test_stat(self):
|
||||
for fn in self.unicodefn:
|
||||
os.stat(os.path.join(self.dir, fn))
|
||||
else:
|
||||
class PosixUidGidTests(unittest.TestCase):
|
||||
pass
|
||||
class Pep383Tests(unittest.TestCase):
|
||||
pass
|
||||
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
class Win32KillTests(unittest.TestCase):
|
||||
|
|
@ -1838,6 +1821,8 @@ class TestSendfile(unittest.TestCase):
|
|||
SUPPORT_HEADERS_TRAILERS = not sys.platform.startswith("linux") and \
|
||||
not sys.platform.startswith("solaris") and \
|
||||
not sys.platform.startswith("sunos")
|
||||
requires_headers_trailers = unittest.skipUnless(SUPPORT_HEADERS_TRAILERS,
|
||||
'requires headers and trailers support')
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
|
|
@ -1956,8 +1941,7 @@ class TestSendfile(unittest.TestCase):
|
|||
|
||||
# --- headers / trailers tests
|
||||
|
||||
if SUPPORT_HEADERS_TRAILERS:
|
||||
|
||||
@requires_headers_trailers
|
||||
def test_headers(self):
|
||||
total_sent = 0
|
||||
sent = os.sendfile(self.sockno, self.fileno, 0, 4096,
|
||||
|
|
@ -1980,6 +1964,7 @@ class TestSendfile(unittest.TestCase):
|
|||
data = self.server.handler_instance.get_data()
|
||||
self.assertEqual(hash(data), hash(expected_data))
|
||||
|
||||
@requires_headers_trailers
|
||||
def test_trailers(self):
|
||||
TESTFN2 = support.TESTFN + "2"
|
||||
file_data = b"abcdef"
|
||||
|
|
@ -1994,7 +1979,9 @@ class TestSendfile(unittest.TestCase):
|
|||
data = self.server.handler_instance.get_data()
|
||||
self.assertEqual(data, b"abcdef1234")
|
||||
|
||||
if hasattr(os, "SF_NODISKIO"):
|
||||
@requires_headers_trailers
|
||||
@unittest.skipUnless(hasattr(os, 'SF_NODISKIO'),
|
||||
'test needs os.SF_NODISKIO')
|
||||
def test_flags(self):
|
||||
try:
|
||||
os.sendfile(self.sockno, self.fileno, 0, 4096,
|
||||
|
|
|
|||
|
|
@ -11,7 +11,7 @@ import os
|
|||
import time
|
||||
import errno
|
||||
|
||||
from unittest import TestCase
|
||||
from unittest import TestCase, skipUnless
|
||||
from test import support as test_support
|
||||
threading = test_support.import_module('threading')
|
||||
|
||||
|
|
@ -288,7 +288,9 @@ if hasattr(poplib, 'POP3_SSL'):
|
|||
else:
|
||||
DummyPOP3Handler.handle_read(self)
|
||||
|
||||
requires_ssl = skipUnless(SUPPORTS_SSL, 'SSL not supported')
|
||||
|
||||
@requires_ssl
|
||||
class TestPOP3_SSLClass(TestPOP3Class):
|
||||
# repeat previous tests by using poplib.POP3_SSL
|
||||
|
||||
|
|
@ -374,9 +376,8 @@ class TestTimeouts(TestCase):
|
|||
|
||||
|
||||
def test_main():
|
||||
tests = [TestPOP3Class, TestTimeouts]
|
||||
if SUPPORTS_SSL:
|
||||
tests.append(TestPOP3_SSLClass)
|
||||
tests = [TestPOP3Class, TestTimeouts,
|
||||
TestPOP3_SSLClass]
|
||||
thread_info = test_support.threading_setup()
|
||||
try:
|
||||
test_support.run_unittest(*tests)
|
||||
|
|
|
|||
|
|
@ -54,27 +54,32 @@ class PosixTester(unittest.TestCase):
|
|||
posix_func()
|
||||
self.assertRaises(TypeError, posix_func, 1)
|
||||
|
||||
if hasattr(posix, 'getresuid'):
|
||||
@unittest.skipUnless(hasattr(posix, 'getresuid'),
|
||||
'test needs posix.getresuid()')
|
||||
def test_getresuid(self):
|
||||
user_ids = posix.getresuid()
|
||||
self.assertEqual(len(user_ids), 3)
|
||||
for val in user_ids:
|
||||
self.assertGreaterEqual(val, 0)
|
||||
|
||||
if hasattr(posix, 'getresgid'):
|
||||
@unittest.skipUnless(hasattr(posix, 'getresgid'),
|
||||
'test needs posix.getresgid()')
|
||||
def test_getresgid(self):
|
||||
group_ids = posix.getresgid()
|
||||
self.assertEqual(len(group_ids), 3)
|
||||
for val in group_ids:
|
||||
self.assertGreaterEqual(val, 0)
|
||||
|
||||
if hasattr(posix, 'setresuid'):
|
||||
@unittest.skipUnless(hasattr(posix, 'setresuid'),
|
||||
'test needs posix.setresuid()')
|
||||
def test_setresuid(self):
|
||||
current_user_ids = posix.getresuid()
|
||||
self.assertIsNone(posix.setresuid(*current_user_ids))
|
||||
# -1 means don't change that value.
|
||||
self.assertIsNone(posix.setresuid(-1, -1, -1))
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'setresuid'),
|
||||
'test needs posix.setresuid()')
|
||||
def test_setresuid_exception(self):
|
||||
# Don't do this test if someone is silly enough to run us as root.
|
||||
current_user_ids = posix.getresuid()
|
||||
|
|
@ -82,13 +87,16 @@ class PosixTester(unittest.TestCase):
|
|||
new_user_ids = (current_user_ids[0]+1, -1, -1)
|
||||
self.assertRaises(OSError, posix.setresuid, *new_user_ids)
|
||||
|
||||
if hasattr(posix, 'setresgid'):
|
||||
@unittest.skipUnless(hasattr(posix, 'setresgid'),
|
||||
'test needs posix.setresgid()')
|
||||
def test_setresgid(self):
|
||||
current_group_ids = posix.getresgid()
|
||||
self.assertIsNone(posix.setresgid(*current_group_ids))
|
||||
# -1 means don't change that value.
|
||||
self.assertIsNone(posix.setresgid(-1, -1, -1))
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'setresgid'),
|
||||
'test needs posix.setresgid()')
|
||||
def test_setresgid_exception(self):
|
||||
# Don't do this test if someone is silly enough to run us as root.
|
||||
current_group_ids = posix.getresgid()
|
||||
|
|
@ -121,12 +129,14 @@ class PosixTester(unittest.TestCase):
|
|||
else:
|
||||
self.fail("Expected OSError to be raised by initgroups")
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'statvfs'),
|
||||
'test needs posix.statvfs()')
|
||||
def test_statvfs(self):
|
||||
if hasattr(posix, 'statvfs'):
|
||||
self.assertTrue(posix.statvfs(os.curdir))
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'fstatvfs'),
|
||||
'test needs posix.fstatvfs()')
|
||||
def test_fstatvfs(self):
|
||||
if hasattr(posix, 'fstatvfs'):
|
||||
fp = open(support.TESTFN)
|
||||
try:
|
||||
self.assertTrue(posix.fstatvfs(fp.fileno()))
|
||||
|
|
@ -134,8 +144,9 @@ class PosixTester(unittest.TestCase):
|
|||
finally:
|
||||
fp.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'ftruncate'),
|
||||
'test needs posix.ftruncate()')
|
||||
def test_ftruncate(self):
|
||||
if hasattr(posix, 'ftruncate'):
|
||||
fp = open(support.TESTFN, 'w+')
|
||||
try:
|
||||
# we need to have some data to truncate
|
||||
|
|
@ -290,8 +301,9 @@ class PosixTester(unittest.TestCase):
|
|||
finally:
|
||||
os.close(fd)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'dup'),
|
||||
'test needs posix.dup()')
|
||||
def test_dup(self):
|
||||
if hasattr(posix, 'dup'):
|
||||
fp = open(support.TESTFN)
|
||||
try:
|
||||
fd = posix.dup(fp.fileno())
|
||||
|
|
@ -300,13 +312,15 @@ class PosixTester(unittest.TestCase):
|
|||
finally:
|
||||
fp.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'confstr'),
|
||||
'test needs posix.confstr()')
|
||||
def test_confstr(self):
|
||||
if hasattr(posix, 'confstr'):
|
||||
self.assertRaises(ValueError, posix.confstr, "CS_garbage")
|
||||
self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'dup2'),
|
||||
'test needs posix.dup2()')
|
||||
def test_dup2(self):
|
||||
if hasattr(posix, 'dup2'):
|
||||
fp1 = open(support.TESTFN)
|
||||
fp2 = open(support.TESTFN)
|
||||
try:
|
||||
|
|
@ -322,8 +336,9 @@ class PosixTester(unittest.TestCase):
|
|||
self.addCleanup(os.close, fd)
|
||||
self.assertTrue(fcntl.fcntl(fd, fcntl.F_GETFD) & fcntl.FD_CLOEXEC)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'O_EXLOCK'),
|
||||
'test needs posix.O_EXLOCK')
|
||||
def test_osexlock(self):
|
||||
if hasattr(posix, "O_EXLOCK"):
|
||||
fd = os.open(support.TESTFN,
|
||||
os.O_WRONLY|os.O_EXLOCK|os.O_CREAT)
|
||||
self.assertRaises(OSError, os.open, support.TESTFN,
|
||||
|
|
@ -337,8 +352,9 @@ class PosixTester(unittest.TestCase):
|
|||
os.O_WRONLY|os.O_EXLOCK|os.O_NONBLOCK)
|
||||
os.close(fd)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'O_SHLOCK'),
|
||||
'test needs posix.O_SHLOCK')
|
||||
def test_osshlock(self):
|
||||
if hasattr(posix, "O_SHLOCK"):
|
||||
fd1 = os.open(support.TESTFN,
|
||||
os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)
|
||||
fd2 = os.open(support.TESTFN,
|
||||
|
|
@ -353,8 +369,9 @@ class PosixTester(unittest.TestCase):
|
|||
os.O_RDONLY|os.O_EXLOCK|os.O_NONBLOCK)
|
||||
os.close(fd)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'fstat'),
|
||||
'test needs posix.fstat()')
|
||||
def test_fstat(self):
|
||||
if hasattr(posix, 'fstat'):
|
||||
fp = open(support.TESTFN)
|
||||
try:
|
||||
self.assertTrue(posix.fstat(fp.fileno()))
|
||||
|
|
@ -366,8 +383,9 @@ class PosixTester(unittest.TestCase):
|
|||
finally:
|
||||
fp.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'stat'),
|
||||
'test needs posix.stat()')
|
||||
def test_stat(self):
|
||||
if hasattr(posix, 'stat'):
|
||||
self.assertTrue(posix.stat(support.TESTFN))
|
||||
self.assertTrue(posix.stat(os.fsencode(support.TESTFN)))
|
||||
self.assertTrue(posix.stat(bytearray(os.fsencode(support.TESTFN))))
|
||||
|
|
@ -495,8 +513,8 @@ class PosixTester(unittest.TestCase):
|
|||
self._test_all_chown_common(posix.lchown, support.TESTFN,
|
||||
getattr(posix, 'lstat', None))
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'chdir'), 'test needs posix.chdir()')
|
||||
def test_chdir(self):
|
||||
if hasattr(posix, 'chdir'):
|
||||
posix.chdir(os.curdir)
|
||||
self.assertRaises(OSError, posix.chdir, support.TESTFN)
|
||||
|
||||
|
|
@ -528,22 +546,23 @@ class PosixTester(unittest.TestCase):
|
|||
sorted(posix.listdir(f))
|
||||
)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'access'), 'test needs posix.access()')
|
||||
def test_access(self):
|
||||
if hasattr(posix, 'access'):
|
||||
self.assertTrue(posix.access(support.TESTFN, os.R_OK))
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'umask'), 'test needs posix.umask()')
|
||||
def test_umask(self):
|
||||
if hasattr(posix, 'umask'):
|
||||
old_mask = posix.umask(0)
|
||||
self.assertIsInstance(old_mask, int)
|
||||
posix.umask(old_mask)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'strerror'),
|
||||
'test needs posix.strerror()')
|
||||
def test_strerror(self):
|
||||
if hasattr(posix, 'strerror'):
|
||||
self.assertTrue(posix.strerror(0))
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'pipe'), 'test needs posix.pipe()')
|
||||
def test_pipe(self):
|
||||
if hasattr(posix, 'pipe'):
|
||||
reader, writer = posix.pipe()
|
||||
os.close(reader)
|
||||
os.close(writer)
|
||||
|
|
@ -578,8 +597,8 @@ class PosixTester(unittest.TestCase):
|
|||
self.assertRaises(OverflowError, os.pipe2, _testcapi.INT_MAX + 1)
|
||||
self.assertRaises(OverflowError, os.pipe2, _testcapi.UINT_MAX + 1)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'utime'), 'test needs posix.utime()')
|
||||
def test_utime(self):
|
||||
if hasattr(posix, 'utime'):
|
||||
now = time.time()
|
||||
posix.utime(support.TESTFN, None)
|
||||
self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None))
|
||||
|
|
@ -663,6 +682,7 @@ class PosixTester(unittest.TestCase):
|
|||
self.assertEqual(type(k), item_type)
|
||||
self.assertEqual(type(v), item_type)
|
||||
|
||||
@unittest.skipUnless(hasattr(posix, 'getcwd'), 'test needs posix.getcwd()')
|
||||
def test_getcwd_long_pathnames(self):
|
||||
if hasattr(posix, 'getcwd'):
|
||||
dirname = 'getcwd-test-directory-0123456789abcdef-01234567890abcdef'
|
||||
|
|
|
|||
|
|
@ -625,8 +625,8 @@ class TestSet(TestJointOps, unittest.TestCase):
|
|||
myset >= myobj
|
||||
self.assertTrue(myobj.le_called)
|
||||
|
||||
# C API test only available in a debug build
|
||||
if hasattr(set, "test_c_api"):
|
||||
@unittest.skipUnless(hasattr(set, "test_c_api"),
|
||||
'C API test only available in a debug build')
|
||||
def test_c_api(self):
|
||||
self.assertEqual(set().test_c_api(), True)
|
||||
|
||||
|
|
|
|||
|
|
@ -194,10 +194,11 @@ class TestShutil(unittest.TestCase):
|
|||
self.assertIn(errors[1][2][1].filename, possible_args)
|
||||
|
||||
|
||||
# See bug #1071513 for why we don't run this on cygwin
|
||||
# and bug #1076467 for why we don't run this as root.
|
||||
if (hasattr(os, 'chmod') and sys.platform[:6] != 'cygwin'
|
||||
and not (hasattr(os, 'geteuid') and os.geteuid() == 0)):
|
||||
@unittest.skipUnless(hasattr(os, 'chmod'), 'requires os.chmod()')
|
||||
@unittest.skipIf(sys.platform[:6] == 'cygwin',
|
||||
"This test can't be run on Cygwin (issue #1071513).")
|
||||
@unittest.skipIf(hasattr(os, 'geteuid') and os.geteuid() == 0,
|
||||
"This test can't be run reliably as root (issue #1076467).")
|
||||
def test_on_error(self):
|
||||
self.errorState = 0
|
||||
os.mkdir(TESTFN)
|
||||
|
|
@ -223,8 +224,7 @@ class TestShutil(unittest.TestCase):
|
|||
shutil.rmtree(TESTFN, onerror=self.check_args_to_onerror)
|
||||
# Test whether onerror has actually been called.
|
||||
self.assertEqual(self.errorState, 3,
|
||||
"Expected call to onerror function did not "
|
||||
"happen.")
|
||||
"Expected call to onerror function did not happen.")
|
||||
|
||||
def check_args_to_onerror(self, func, arg, exc):
|
||||
# test_rmtree_errors deliberately runs rmtree
|
||||
|
|
@ -806,8 +806,8 @@ class TestShutil(unittest.TestCase):
|
|||
finally:
|
||||
shutil.rmtree(TESTFN, ignore_errors=True)
|
||||
|
||||
if hasattr(os, "mkfifo"):
|
||||
# Issue #3002: copyfile and copytree block indefinitely on named pipes
|
||||
@unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
|
||||
def test_copyfile_named_pipe(self):
|
||||
os.mkfifo(TESTFN)
|
||||
try:
|
||||
|
|
@ -818,6 +818,7 @@ class TestShutil(unittest.TestCase):
|
|||
finally:
|
||||
os.remove(TESTFN)
|
||||
|
||||
@unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
|
||||
@support.skip_unless_symlink
|
||||
def test_copytree_named_pipe(self):
|
||||
os.mkdir(TESTFN)
|
||||
|
|
|
|||
|
|
@ -772,9 +772,10 @@ class GeneralModuleTests(unittest.TestCase):
|
|||
self.assertRaises(TypeError, socket.if_nametoindex, 0)
|
||||
self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
|
||||
|
||||
@unittest.skipUnless(hasattr(sys, 'getrefcount'),
|
||||
'test needs sys.getrefcount()')
|
||||
def testRefCountGetNameInfo(self):
|
||||
# Testing reference count for getnameinfo
|
||||
if hasattr(sys, "getrefcount"):
|
||||
try:
|
||||
# On some versions, this loses a reference
|
||||
orig = sys.getrefcount(__name__)
|
||||
|
|
@ -886,17 +887,17 @@ class GeneralModuleTests(unittest.TestCase):
|
|||
# Check that setting it to an invalid type raises TypeError
|
||||
self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'inet_aton'),
|
||||
'test needs socket.inet_aton()')
|
||||
def testIPv4_inet_aton_fourbytes(self):
|
||||
if not hasattr(socket, 'inet_aton'):
|
||||
return # No inet_aton, nothing to check
|
||||
# Test that issue1008086 and issue767150 are fixed.
|
||||
# It must return 4 bytes.
|
||||
self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0'))
|
||||
self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255'))
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'inet_pton'),
|
||||
'test needs socket.inet_pton()')
|
||||
def testIPv4toString(self):
|
||||
if not hasattr(socket, 'inet_pton'):
|
||||
return # No inet_pton() on this platform
|
||||
from socket import inet_aton as f, inet_pton, AF_INET
|
||||
g = lambda a: inet_pton(AF_INET, a)
|
||||
|
||||
|
|
@ -925,9 +926,9 @@ class GeneralModuleTests(unittest.TestCase):
|
|||
assertInvalid(g, '1.2.3.4.5')
|
||||
assertInvalid(g, '::1')
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'inet_pton'),
|
||||
'test needs socket.inet_pton()')
|
||||
def testIPv6toString(self):
|
||||
if not hasattr(socket, 'inet_pton'):
|
||||
return # No inet_pton() on this platform
|
||||
try:
|
||||
from socket import inet_pton, AF_INET6, has_ipv6
|
||||
if not has_ipv6:
|
||||
|
|
@ -979,9 +980,9 @@ class GeneralModuleTests(unittest.TestCase):
|
|||
assertInvalid('::1.2.3.4:0')
|
||||
assertInvalid('0.100.200.0:3:4:5:6:7:8')
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'inet_ntop'),
|
||||
'test needs socket.inet_ntop()')
|
||||
def testStringToIPv4(self):
|
||||
if not hasattr(socket, 'inet_ntop'):
|
||||
return # No inet_ntop() on this platform
|
||||
from socket import inet_ntoa as f, inet_ntop, AF_INET
|
||||
g = lambda a: inet_ntop(AF_INET, a)
|
||||
assertInvalid = lambda func,a: self.assertRaises(
|
||||
|
|
@ -1003,9 +1004,9 @@ class GeneralModuleTests(unittest.TestCase):
|
|||
assertInvalid(g, b'\x00' * 5)
|
||||
assertInvalid(g, b'\x00' * 16)
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'inet_ntop'),
|
||||
'test needs socket.inet_ntop()')
|
||||
def testStringToIPv6(self):
|
||||
if not hasattr(socket, 'inet_ntop'):
|
||||
return # No inet_ntop() on this platform
|
||||
try:
|
||||
from socket import inet_ntop, AF_INET6, has_ipv6
|
||||
if not has_ipv6:
|
||||
|
|
@ -3531,6 +3532,8 @@ class TCPCloserTest(ThreadedTCPSocketTest):
|
|||
self.cli.connect((HOST, self.port))
|
||||
time.sleep(1.0)
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'socketpair'),
|
||||
'test needs socket.socketpair()')
|
||||
@unittest.skipUnless(thread, 'Threading required for this test.')
|
||||
class BasicSocketPairTest(SocketPairTest):
|
||||
|
||||
|
|
@ -3593,7 +3596,8 @@ class NonBlockingTCPTests(ThreadedTCPSocketTest):
|
|||
def _testSetBlocking(self):
|
||||
pass
|
||||
|
||||
if hasattr(socket, "SOCK_NONBLOCK"):
|
||||
@unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
|
||||
'test needs socket.SOCK_NONBLOCK')
|
||||
@support.requires_linux_version(2, 6, 28)
|
||||
def testInitNonBlocking(self):
|
||||
# reinit server socket
|
||||
|
|
@ -4302,12 +4306,12 @@ class TCPTimeoutTest(SocketTCPTest):
|
|||
if not ok:
|
||||
self.fail("accept() returned success when we did not expect it")
|
||||
|
||||
@unittest.skipUnless(hasattr(signal, 'alarm'),
|
||||
'test needs signal.alarm()')
|
||||
def testInterruptedTimeout(self):
|
||||
# XXX I don't know how to do this test on MSWindows or any other
|
||||
# plaform that doesn't support signal.alarm() or os.kill(), though
|
||||
# the bug should have existed on all platforms.
|
||||
if not hasattr(signal, "alarm"):
|
||||
return # can only test on *nix
|
||||
self.serv.settimeout(5.0) # must be longer than alarm
|
||||
class Alarm(Exception):
|
||||
pass
|
||||
|
|
@ -4367,6 +4371,7 @@ class TestExceptions(unittest.TestCase):
|
|||
self.assertTrue(issubclass(socket.gaierror, socket.error))
|
||||
self.assertTrue(issubclass(socket.timeout, socket.error))
|
||||
|
||||
@unittest.skipUnless(sys.platform == 'linux', 'Linux specific test')
|
||||
class TestLinuxAbstractNamespace(unittest.TestCase):
|
||||
|
||||
UNIX_PATH_MAX = 108
|
||||
|
|
@ -4402,6 +4407,7 @@ class TestLinuxAbstractNamespace(unittest.TestCase):
|
|||
finally:
|
||||
s.close()
|
||||
|
||||
@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'test needs socket.AF_UNIX')
|
||||
class TestUnixDomain(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
|
|
@ -4551,10 +4557,10 @@ def isTipcAvailable():
|
|||
for line in f:
|
||||
if line.startswith("tipc "):
|
||||
return True
|
||||
if support.verbose:
|
||||
print("TIPC module is not loaded, please 'sudo modprobe tipc'")
|
||||
return False
|
||||
|
||||
@unittest.skipUnless(isTipcAvailable(),
|
||||
"TIPC module is not loaded, please 'sudo modprobe tipc'")
|
||||
class TIPCTest(unittest.TestCase):
|
||||
def testRDM(self):
|
||||
srv = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
|
||||
|
|
@ -4577,6 +4583,8 @@ class TIPCTest(unittest.TestCase):
|
|||
self.assertEqual(msg, MSG)
|
||||
|
||||
|
||||
@unittest.skipUnless(isTipcAvailable(),
|
||||
"TIPC module is not loaded, please 'sudo modprobe tipc'")
|
||||
class TIPCThreadableTest(unittest.TestCase, ThreadableTest):
|
||||
def __init__(self, methodName = 'runTest'):
|
||||
unittest.TestCase.__init__(self, methodName = methodName)
|
||||
|
|
@ -4842,15 +4850,10 @@ def test_main():
|
|||
CloexecConstantTest,
|
||||
NonblockConstantTest
|
||||
])
|
||||
if hasattr(socket, "socketpair"):
|
||||
tests.append(BasicSocketPairTest)
|
||||
if hasattr(socket, "AF_UNIX"):
|
||||
tests.append(TestUnixDomain)
|
||||
if sys.platform == 'linux':
|
||||
tests.append(TestLinuxAbstractNamespace)
|
||||
if isTipcAvailable():
|
||||
tests.append(TIPCTest)
|
||||
tests.append(TIPCThreadableTest)
|
||||
tests.extend([TIPCTest, TIPCThreadableTest])
|
||||
tests.extend([BasicCANTest, CANTest])
|
||||
tests.extend([BasicRDSTest, RDSTest])
|
||||
tests.extend([
|
||||
|
|
|
|||
|
|
@ -27,7 +27,10 @@ TEST_STR = b"hello world\n"
|
|||
HOST = test.support.HOST
|
||||
|
||||
HAVE_UNIX_SOCKETS = hasattr(socket, "AF_UNIX")
|
||||
requires_unix_sockets = unittest.skipUnless(HAVE_UNIX_SOCKETS,
|
||||
'requires Unix sockets')
|
||||
HAVE_FORKING = hasattr(os, "fork") and os.name != "os2"
|
||||
requires_forking = unittest.skipUnless(HAVE_FORKING, 'requires forking')
|
||||
|
||||
def signal_alarm(n):
|
||||
"""Call signal.alarm when it exists (i.e. not on Windows)."""
|
||||
|
|
@ -189,25 +192,27 @@ class SocketServerTest(unittest.TestCase):
|
|||
socketserver.StreamRequestHandler,
|
||||
self.stream_examine)
|
||||
|
||||
if HAVE_FORKING:
|
||||
@requires_forking
|
||||
def test_ForkingTCPServer(self):
|
||||
with simple_subprocess(self):
|
||||
self.run_server(socketserver.ForkingTCPServer,
|
||||
socketserver.StreamRequestHandler,
|
||||
self.stream_examine)
|
||||
|
||||
if HAVE_UNIX_SOCKETS:
|
||||
@requires_unix_sockets
|
||||
def test_UnixStreamServer(self):
|
||||
self.run_server(socketserver.UnixStreamServer,
|
||||
socketserver.StreamRequestHandler,
|
||||
self.stream_examine)
|
||||
|
||||
@requires_unix_sockets
|
||||
def test_ThreadingUnixStreamServer(self):
|
||||
self.run_server(socketserver.ThreadingUnixStreamServer,
|
||||
socketserver.StreamRequestHandler,
|
||||
self.stream_examine)
|
||||
|
||||
if HAVE_FORKING:
|
||||
@requires_unix_sockets
|
||||
@requires_forking
|
||||
def test_ForkingUnixStreamServer(self):
|
||||
with simple_subprocess(self):
|
||||
self.run_server(ForkingUnixStreamServer,
|
||||
|
|
@ -224,7 +229,7 @@ class SocketServerTest(unittest.TestCase):
|
|||
socketserver.DatagramRequestHandler,
|
||||
self.dgram_examine)
|
||||
|
||||
if HAVE_FORKING:
|
||||
@requires_forking
|
||||
def test_ForkingUDPServer(self):
|
||||
with simple_subprocess(self):
|
||||
self.run_server(socketserver.ForkingUDPServer,
|
||||
|
|
@ -266,18 +271,20 @@ class SocketServerTest(unittest.TestCase):
|
|||
# Alas, on Linux (at least) recvfrom() doesn't return a meaningful
|
||||
# client address so this cannot work:
|
||||
|
||||
# if HAVE_UNIX_SOCKETS:
|
||||
# @requires_unix_sockets
|
||||
# def test_UnixDatagramServer(self):
|
||||
# self.run_server(socketserver.UnixDatagramServer,
|
||||
# socketserver.DatagramRequestHandler,
|
||||
# self.dgram_examine)
|
||||
#
|
||||
# @requires_unix_sockets
|
||||
# def test_ThreadingUnixDatagramServer(self):
|
||||
# self.run_server(socketserver.ThreadingUnixDatagramServer,
|
||||
# socketserver.DatagramRequestHandler,
|
||||
# self.dgram_examine)
|
||||
#
|
||||
# if HAVE_FORKING:
|
||||
# @requires_unix_sockets
|
||||
# @requires_forking
|
||||
# def test_ForkingUnixDatagramServer(self):
|
||||
# self.run_server(socketserver.ForkingUnixDatagramServer,
|
||||
# socketserver.DatagramRequestHandler,
|
||||
|
|
|
|||
|
|
@ -291,8 +291,9 @@ class SysModuleTest(unittest.TestCase):
|
|||
def test_call_tracing(self):
|
||||
self.assertRaises(TypeError, sys.call_tracing, type, 2)
|
||||
|
||||
@unittest.skipUnless(hasattr(sys, "setdlopenflags"),
|
||||
'test needs sys.setdlopenflags()')
|
||||
def test_dlopenflags(self):
|
||||
if hasattr(sys, "setdlopenflags"):
|
||||
self.assertTrue(hasattr(sys, "getdlopenflags"))
|
||||
self.assertRaises(TypeError, sys.getdlopenflags, 42)
|
||||
oldflags = sys.getdlopenflags()
|
||||
|
|
|
|||
|
|
@ -271,11 +271,10 @@ class WarnTests(BaseTest):
|
|||
finally:
|
||||
warning_tests.__file__ = filename
|
||||
|
||||
@unittest.skipUnless(hasattr(sys, 'argv'), 'test needs sys.argv')
|
||||
def test_missing_filename_main_with_argv(self):
|
||||
# If __file__ is not specified and the caller is __main__ and sys.argv
|
||||
# exists, then use sys.argv[0] as the file.
|
||||
if not hasattr(sys, 'argv'):
|
||||
return
|
||||
filename = warning_tests.__file__
|
||||
module_name = warning_tests.__name__
|
||||
try:
|
||||
|
|
|
|||
|
|
@ -7,6 +7,13 @@ from test.support import bigmemtest, _1G, _4G
|
|||
|
||||
zlib = support.import_module('zlib')
|
||||
|
||||
requires_Compress_copy = unittest.skipUnless(
|
||||
hasattr(zlib.compressobj(), "copy"),
|
||||
'requires Compress.copy()')
|
||||
requires_Decompress_copy = unittest.skipUnless(
|
||||
hasattr(zlib.decompressobj(), "copy"),
|
||||
'requires Decompress.copy()')
|
||||
|
||||
|
||||
class VersionTestCase(unittest.TestCase):
|
||||
|
||||
|
|
@ -381,11 +388,11 @@ class CompressObjectTestCase(BaseCompressTestCase, unittest.TestCase):
|
|||
"mode=%i, level=%i") % (sync, level))
|
||||
del obj
|
||||
|
||||
@unittest.skipUnless(hasattr(zlib, 'Z_SYNC_FLUSH'),
|
||||
'requires zlib.Z_SYNC_FLUSH')
|
||||
def test_odd_flush(self):
|
||||
# Test for odd flushing bugs noted in 2.0, and hopefully fixed in 2.1
|
||||
import random
|
||||
|
||||
if hasattr(zlib, 'Z_SYNC_FLUSH'):
|
||||
# Testing on 17K of "random" data
|
||||
|
||||
# Create compressor and decompressor objects
|
||||
|
|
@ -525,7 +532,7 @@ class CompressObjectTestCase(BaseCompressTestCase, unittest.TestCase):
|
|||
data = zlib.compress(input2)
|
||||
self.assertEqual(dco.flush(), input1[1:])
|
||||
|
||||
if hasattr(zlib.compressobj(), "copy"):
|
||||
@requires_Compress_copy
|
||||
def test_compresscopy(self):
|
||||
# Test copying a compression object
|
||||
data0 = HAMLET_SCENE
|
||||
|
|
@ -548,6 +555,7 @@ class CompressObjectTestCase(BaseCompressTestCase, unittest.TestCase):
|
|||
self.assertEqual(zlib.decompress(s0),data0+data0)
|
||||
self.assertEqual(zlib.decompress(s1),data0+data1)
|
||||
|
||||
@requires_Compress_copy
|
||||
def test_badcompresscopy(self):
|
||||
# Test copying a compression object in an inconsistent state
|
||||
c = zlib.compressobj()
|
||||
|
|
@ -555,7 +563,7 @@ class CompressObjectTestCase(BaseCompressTestCase, unittest.TestCase):
|
|||
c.flush()
|
||||
self.assertRaises(ValueError, c.copy)
|
||||
|
||||
if hasattr(zlib.decompressobj(), "copy"):
|
||||
@requires_Decompress_copy
|
||||
def test_decompresscopy(self):
|
||||
# Test copying a decompression object
|
||||
data = HAMLET_SCENE
|
||||
|
|
@ -579,6 +587,7 @@ class CompressObjectTestCase(BaseCompressTestCase, unittest.TestCase):
|
|||
self.assertEqual(s0,s1)
|
||||
self.assertEqual(s0,data)
|
||||
|
||||
@requires_Decompress_copy
|
||||
def test_baddecompresscopy(self):
|
||||
# Test copying a compression object in an inconsistent state
|
||||
data = zlib.compress(HAMLET_SCENE)
|
||||
|
|
|
|||
|
|
@ -29,6 +29,8 @@ Library
|
|||
Tests
|
||||
-----
|
||||
|
||||
- Issue #18702: All skipped tests now reported as skipped.
|
||||
|
||||
- Issue #19085: Added basic tests for all tkinter widget options.
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue