mirror of
https://github.com/python/cpython
synced 2024-10-02 00:22:54 +00:00
Issue 19572: More silently skipped tests explicitly skipped.
This commit is contained in:
parent
774f909489
commit
9fe6d86709
|
@ -2025,6 +2025,7 @@ def newmeth(self, start):
|
|||
class TestSubclassDateTime(TestDateTime):
|
||||
theclass = SubclassDatetime
|
||||
# Override tests not designed for subclass
|
||||
@unittest.skip('not appropriate for subclasses')
|
||||
def test_roundtrip(self):
|
||||
pass
|
||||
|
||||
|
|
|
@ -73,7 +73,7 @@ def test_errorhandle(self):
|
|||
|
||||
def test_xmlcharrefreplace(self):
|
||||
if self.has_iso10646:
|
||||
return
|
||||
self.skipTest('encoding contains full ISO 10646 map')
|
||||
|
||||
s = "\u0b13\u0b23\u0b60 nd eggs"
|
||||
self.assertEqual(
|
||||
|
@ -83,7 +83,7 @@ def test_xmlcharrefreplace(self):
|
|||
|
||||
def test_customreplace_encode(self):
|
||||
if self.has_iso10646:
|
||||
return
|
||||
self.skipTest('encoding contains full ISO 10646 map')
|
||||
|
||||
from html.entities import codepoint2name
|
||||
|
||||
|
|
|
@ -663,10 +663,10 @@ def test_replace(self):
|
|||
self.checkraises(TypeError, 'hello', 'replace', 42, 'h')
|
||||
self.checkraises(TypeError, 'hello', 'replace', 'h', 42)
|
||||
|
||||
@unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
|
||||
'only applies to 32-bit platforms')
|
||||
def test_replace_overflow(self):
|
||||
# Check for overflow checking on 32 bit machines
|
||||
if sys.maxsize != 2147483647 or struct.calcsize("P") > 4:
|
||||
return
|
||||
A2_16 = "A" * (2**16)
|
||||
self.checkraises(OverflowError, A2_16, "replace", "", A2_16)
|
||||
self.checkraises(OverflowError, A2_16, "replace", "A", A2_16)
|
||||
|
|
|
@ -946,7 +946,7 @@ def test_coveritertraverse(self):
|
|||
try:
|
||||
import gc
|
||||
except ImportError:
|
||||
return
|
||||
self.skipTest('gc module not available')
|
||||
a = array.array(self.typecode)
|
||||
l = [iter(a)]
|
||||
l.append(l)
|
||||
|
|
|
@ -36,6 +36,7 @@ class Test_ISO2022_KR(multibytecodec_support.TestBase, unittest.TestCase):
|
|||
|
||||
# iso2022_kr.txt cannot be used to test "chunk coding": the escape
|
||||
# sequence is only written on the first line
|
||||
@unittest.skip('iso2022_kr.txt cannot be used to test "chunk coding"')
|
||||
def test_chunkcoding(self):
|
||||
pass
|
||||
|
||||
|
|
|
@ -707,8 +707,7 @@ class mystr(str):
|
|||
|
||||
def test_read_returns_file_list(self):
|
||||
if self.delimiters[0] != '=':
|
||||
# skip reading the file if we're using an incompatible format
|
||||
return
|
||||
self.skipTest('incompatible format')
|
||||
file1 = support.findfile("cfgparser.1")
|
||||
# check when we pass a mix of readable and non-readable files:
|
||||
cf = self.newconfig()
|
||||
|
|
|
@ -290,7 +290,6 @@ def eval_file(self, file):
|
|||
global skip_expected
|
||||
if skip_expected:
|
||||
raise unittest.SkipTest
|
||||
return
|
||||
with open(file) as f:
|
||||
for line in f:
|
||||
line = line.replace('\r\n', '').replace('\n', '')
|
||||
|
@ -301,7 +300,6 @@ def eval_file(self, file):
|
|||
#Exception raised where there shouldn't have been one.
|
||||
self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line)
|
||||
|
||||
return
|
||||
|
||||
def eval_line(self, s):
|
||||
if s.find(' -> ') >= 0 and s[:2] != '--' and not s.startswith(' --'):
|
||||
|
@ -461,7 +459,6 @@ def FixQuotes(val):
|
|||
|
||||
self.assertEqual(myexceptions, theirexceptions,
|
||||
'Incorrect flags set in ' + s + ' -- got ' + str(myexceptions))
|
||||
return
|
||||
|
||||
def getexceptions(self):
|
||||
return [e for e in Signals[self.decimal] if self.context.flags[e]]
|
||||
|
@ -1073,7 +1070,7 @@ def test_n_format(self):
|
|||
try:
|
||||
from locale import CHAR_MAX
|
||||
except ImportError:
|
||||
return
|
||||
self.skipTest('locale.CHAR_MAX not available')
|
||||
|
||||
def make_grouping(lst):
|
||||
return ''.join([chr(x) for x in lst]) if self.decimal == C else lst
|
||||
|
@ -1164,8 +1161,12 @@ def test_wide_char_separator_decimal_point(self):
|
|||
|
||||
decimal_point = locale.localeconv()['decimal_point']
|
||||
thousands_sep = locale.localeconv()['thousands_sep']
|
||||
if decimal_point != '\u066b' or thousands_sep != '\u066c':
|
||||
return
|
||||
if decimal_point != '\u066b':
|
||||
self.skipTest('inappropriate decimal point separator'
|
||||
'({!r} not {!r})'.format(decimal_point, '\u066b'))
|
||||
if thousands_sep != '\u066c':
|
||||
self.skipTest('inappropriate thousands separator'
|
||||
'({!r} not {!r})'.format(thousands_sep, '\u066c'))
|
||||
|
||||
self.assertEqual(format(Decimal('100000000.123'), 'n'),
|
||||
'100\u066c000\u066c000\u066b123')
|
||||
|
@ -1515,7 +1516,6 @@ def thfunc1(cls):
|
|||
cls.assertTrue(c1.flags[Inexact])
|
||||
for sig in Overflow, Underflow, DivisionByZero, InvalidOperation:
|
||||
cls.assertFalse(c1.flags[sig])
|
||||
return
|
||||
|
||||
def thfunc2(cls):
|
||||
Decimal = cls.decimal.Decimal
|
||||
|
@ -1560,7 +1560,6 @@ def thfunc2(cls):
|
|||
cls.assertTrue(thiscontext.flags[Inexact])
|
||||
for sig in Overflow, Underflow, DivisionByZero, InvalidOperation:
|
||||
cls.assertFalse(thiscontext.flags[sig])
|
||||
return
|
||||
|
||||
class ThreadingTest(unittest.TestCase):
|
||||
'''Unit tests for thread local contexts in Decimal.'''
|
||||
|
@ -1602,7 +1601,6 @@ def test_threading(self):
|
|||
DefaultContext.prec = save_prec
|
||||
DefaultContext.Emax = save_emax
|
||||
DefaultContext.Emin = save_emin
|
||||
return
|
||||
|
||||
@unittest.skipUnless(threading, 'threading required')
|
||||
class CThreadingTest(ThreadingTest):
|
||||
|
@ -4525,7 +4523,6 @@ def checkSameDec(operation, useOther=False):
|
|||
self.assertEqual(d1._sign, b1._sign)
|
||||
self.assertEqual(d1._int, b1._int)
|
||||
self.assertEqual(d1._exp, b1._exp)
|
||||
return
|
||||
|
||||
Decimal(d1)
|
||||
self.assertEqual(d1._sign, b1._sign)
|
||||
|
@ -5271,7 +5268,7 @@ def test_invalid_override(self):
|
|||
try:
|
||||
from locale import CHAR_MAX
|
||||
except ImportError:
|
||||
return
|
||||
self.skipTest('locale.CHAR_MAX not available')
|
||||
|
||||
def make_grouping(lst):
|
||||
return ''.join([chr(x) for x in lst])
|
||||
|
|
|
@ -217,16 +217,18 @@ def test_dis(self):
|
|||
def test_bug_708901(self):
|
||||
self.do_disassembly_test(bug708901, dis_bug708901)
|
||||
|
||||
# Test has been disabled due to change in the way
|
||||
# list comps are handled. The byte code now includes
|
||||
# a memory address and a file location, so they change from
|
||||
# run to run.
|
||||
@unittest.skip('disabled due to a change in the way list comps are handled')
|
||||
def test_bug_1333982(self):
|
||||
# XXX: re-enable this test!
|
||||
# This one is checking bytecodes generated for an `assert` statement,
|
||||
# so fails if the tests are run with -O. Skip this test then.
|
||||
pass # Test has been disabled due to change in the way
|
||||
# list comps are handled. The byte code now includes
|
||||
# a memory address and a file location, so they change from
|
||||
# run to run.
|
||||
# if __debug__:
|
||||
# self.do_disassembly_test(bug1333982, dis_bug1333982)
|
||||
|
||||
if __debug__:
|
||||
self.do_disassembly_test(bug1333982, dis_bug1333982)
|
||||
|
||||
def test_big_linenos(self):
|
||||
def func(count):
|
||||
|
|
|
@ -341,8 +341,7 @@ def testBytesOpen(self):
|
|||
try:
|
||||
fn = TESTFN.encode("ascii")
|
||||
except UnicodeEncodeError:
|
||||
# Skip test
|
||||
return
|
||||
self.skipTest('could not encode %r to ascii' % TESTFN)
|
||||
f = _FileIO(fn, "w")
|
||||
try:
|
||||
f.write(b"abc")
|
||||
|
|
|
@ -70,7 +70,7 @@ def test_float_with_comma(self):
|
|||
# it still has to accept the normal python syntax
|
||||
import locale
|
||||
if not locale.localeconv()['decimal_point'] == ',':
|
||||
return
|
||||
self.skipTest('decimal_point is not ","')
|
||||
|
||||
self.assertEqual(float(" 3.14 "), 3.14)
|
||||
self.assertEqual(float("+3.14 "), 3.14)
|
||||
|
|
|
@ -45,8 +45,6 @@ def test_attributes(self):
|
|||
self.assertEqual(p.args, (1, 2))
|
||||
self.assertEqual(p.keywords, dict(a=10, b=20))
|
||||
# attributes should not be writable
|
||||
if not isinstance(self.thetype, type):
|
||||
return
|
||||
self.assertRaises(AttributeError, setattr, p, 'func', map)
|
||||
self.assertRaises(AttributeError, setattr, p, 'args', (1, 2))
|
||||
self.assertRaises(AttributeError, setattr, p, 'keywords', dict(a=1, b=2))
|
||||
|
@ -210,11 +208,13 @@ class TestPythonPartial(TestPartial):
|
|||
thetype = PythonPartial
|
||||
|
||||
# the python version hasn't a nice repr
|
||||
def test_repr(self): pass
|
||||
test_repr = None
|
||||
|
||||
# the python version isn't picklable
|
||||
def test_pickle(self): pass
|
||||
def test_setstate_refcount(self): pass
|
||||
test_pickle = test_setstate_refcount = None
|
||||
|
||||
# the python version isn't a type
|
||||
test_attributes = None
|
||||
|
||||
class TestUpdateWrapper(unittest.TestCase):
|
||||
|
||||
|
|
|
@ -26,8 +26,10 @@ def test_values(self):
|
|||
for e in entries:
|
||||
self.check_value(e)
|
||||
|
||||
def test_values_extended(self):
|
||||
entries = grp.getgrall()
|
||||
if len(entries) > 1000: # Huge group file (NIS?) -- skip the rest
|
||||
return
|
||||
self.skipTest('huge group file, extended test skipped')
|
||||
|
||||
for e in entries:
|
||||
e2 = grp.getgrgid(e.gr_gid)
|
||||
|
|
|
@ -245,7 +245,7 @@ def test_load_module_extension_file_is_None(self):
|
|||
if found[0] is not None:
|
||||
found[0].close()
|
||||
if found[2][2] != imp.C_EXTENSION:
|
||||
return
|
||||
self.skipTest("found module doesn't appear to be a C extension")
|
||||
imp.load_module(name, None, *found[1:])
|
||||
|
||||
def test_multiple_calls_to_get_data(self):
|
||||
|
|
|
@ -421,14 +421,9 @@ def test_large_file_ops(self):
|
|||
# a long time to build the >2GB file and takes >2GB of disk space
|
||||
# therefore the resource must be enabled to run this test.
|
||||
if sys.platform[:3] == 'win' or sys.platform == 'darwin':
|
||||
if not support.is_resource_enabled("largefile"):
|
||||
print("\nTesting large file ops skipped on %s." % sys.platform,
|
||||
file=sys.stderr)
|
||||
print("It requires %d bytes and a long time." % self.LARGE,
|
||||
file=sys.stderr)
|
||||
print("Use 'regrtest.py -u largefile test_io' to run it.",
|
||||
file=sys.stderr)
|
||||
return
|
||||
support.requires(
|
||||
'largefile',
|
||||
'test requires %s bytes and a long time to run' % self.LARGE)
|
||||
with self.open(support.TESTFN, "w+b", 0) as f:
|
||||
self.large_file_ops(f)
|
||||
with self.open(support.TESTFN, "w+b") as f:
|
||||
|
@ -698,6 +693,7 @@ def test_fileno(self):
|
|||
|
||||
self.assertEqual(42, bufio.fileno())
|
||||
|
||||
@unittest.skip('test having existential crisis')
|
||||
def test_no_fileno(self):
|
||||
# XXX will we always have fileno() function? If so, kill
|
||||
# this test. Else, write it.
|
||||
|
|
|
@ -57,7 +57,7 @@ def test_iter(self):
|
|||
|
||||
def test_setitem_readonly(self):
|
||||
if not self.ro_type:
|
||||
return
|
||||
self.skipTest("no read-only type to test")
|
||||
b = self.ro_type(self._source)
|
||||
oldrefcount = sys.getrefcount(b)
|
||||
m = self._view(b)
|
||||
|
@ -71,7 +71,7 @@ def setitem(value):
|
|||
|
||||
def test_setitem_writable(self):
|
||||
if not self.rw_type:
|
||||
return
|
||||
self.skipTest("no writable type to test")
|
||||
tp = self.rw_type
|
||||
b = self.rw_type(self._source)
|
||||
oldrefcount = sys.getrefcount(b)
|
||||
|
@ -189,13 +189,13 @@ def check_attributes_with_type(self, tp):
|
|||
|
||||
def test_attributes_readonly(self):
|
||||
if not self.ro_type:
|
||||
return
|
||||
self.skipTest("no read-only type to test")
|
||||
m = self.check_attributes_with_type(self.ro_type)
|
||||
self.assertEqual(m.readonly, True)
|
||||
|
||||
def test_attributes_writable(self):
|
||||
if not self.rw_type:
|
||||
return
|
||||
self.skipTest("no writable type to test")
|
||||
m = self.check_attributes_with_type(self.rw_type)
|
||||
self.assertEqual(m.readonly, False)
|
||||
|
||||
|
@ -301,7 +301,7 @@ def test_writable_readonly(self):
|
|||
# buffer as writable causing a segfault if using mmap
|
||||
tp = self.ro_type
|
||||
if tp is None:
|
||||
return
|
||||
self.skipTest("no read-only type to test")
|
||||
b = tp(self._source)
|
||||
m = self._view(b)
|
||||
i = io.BytesIO(b'ZZZZ')
|
||||
|
@ -370,12 +370,12 @@ class BaseArrayMemoryTests(AbstractMemoryTests):
|
|||
itemsize = array.array('i').itemsize
|
||||
format = 'i'
|
||||
|
||||
@unittest.skip('XXX test should be adapted for non-byte buffers')
|
||||
def test_getbuffer(self):
|
||||
# XXX Test should be adapted for non-byte buffers
|
||||
pass
|
||||
|
||||
@unittest.skip('XXX NotImplementedError: tolist() only supports byte views')
|
||||
def test_tolist(self):
|
||||
# XXX NotImplementedError: tolist() only supports byte views
|
||||
pass
|
||||
|
||||
|
||||
|
|
|
@ -195,7 +195,7 @@ class _TestProcess(BaseTestCase):
|
|||
|
||||
def test_current(self):
|
||||
if self.TYPE == 'threads':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
current = self.current_process()
|
||||
authkey = current.authkey
|
||||
|
@ -209,7 +209,7 @@ def test_current(self):
|
|||
|
||||
def test_daemon_argument(self):
|
||||
if self.TYPE == "threads":
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
# By default uses the current process's daemon flag.
|
||||
proc0 = self.Process(target=self._test)
|
||||
|
@ -274,7 +274,7 @@ def _test_terminate(cls):
|
|||
|
||||
def test_terminate(self):
|
||||
if self.TYPE == 'threads':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
p = self.Process(target=self._test_terminate)
|
||||
p.daemon = True
|
||||
|
@ -378,7 +378,7 @@ def _test_sentinel(cls, event):
|
|||
|
||||
def test_sentinel(self):
|
||||
if self.TYPE == "threads":
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
event = self.Event()
|
||||
p = self.Process(target=self._test_sentinel, args=(event,))
|
||||
with self.assertRaises(ValueError):
|
||||
|
@ -434,7 +434,7 @@ def test_subclassing(self):
|
|||
def test_stderr_flush(self):
|
||||
# sys.stderr is flushed at process shutdown (issue #13812)
|
||||
if self.TYPE == "threads":
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
testfn = test.support.TESTFN
|
||||
self.addCleanup(test.support.unlink, testfn)
|
||||
|
@ -462,7 +462,7 @@ def _test_sys_exit(cls, reason, testfn):
|
|||
def test_sys_exit(self):
|
||||
# See Issue 13854
|
||||
if self.TYPE == 'threads':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
testfn = test.support.TESTFN
|
||||
self.addCleanup(test.support.unlink, testfn)
|
||||
|
@ -671,7 +671,7 @@ def test_qsize(self):
|
|||
try:
|
||||
self.assertEqual(q.qsize(), 0)
|
||||
except NotImplementedError:
|
||||
return
|
||||
self.skipTest('qsize method not implemented')
|
||||
q.put(1)
|
||||
self.assertEqual(q.qsize(), 1)
|
||||
q.put(5)
|
||||
|
@ -779,7 +779,7 @@ def test_bounded_semaphore(self):
|
|||
|
||||
def test_timeout(self):
|
||||
if self.TYPE != 'processes':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
sem = self.Semaphore(0)
|
||||
acquire = TimingWrapper(sem.acquire)
|
||||
|
@ -1399,7 +1399,7 @@ def _test_thousand_f(cls, barrier, passes, conn, lock):
|
|||
|
||||
def test_thousand(self):
|
||||
if self.TYPE == 'manager':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
passes = 1000
|
||||
lock = self.Lock()
|
||||
conn, child_conn = self.Pipe(False)
|
||||
|
@ -1694,7 +1694,7 @@ def test_map_async_callbacks(self):
|
|||
def test_map_unplicklable(self):
|
||||
# Issue #19425 -- failure to pickle should not cause a hang
|
||||
if self.TYPE == 'threads':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
class A(object):
|
||||
def __reduce__(self):
|
||||
raise RuntimeError('cannot pickle')
|
||||
|
@ -2188,7 +2188,7 @@ def test_spawn_close(self):
|
|||
|
||||
def test_sendbytes(self):
|
||||
if self.TYPE != 'processes':
|
||||
return
|
||||
self.skipTest('test not appropriate for {}'.format(self.TYPE))
|
||||
|
||||
msg = latin('abcdefghijklmnopqrstuvwxyz')
|
||||
a, b = self.Pipe()
|
||||
|
|
|
@ -12,11 +12,7 @@ def test_maps(self):
|
|||
maps = nis.maps()
|
||||
except nis.error as msg:
|
||||
# NIS is probably not active, so this test isn't useful
|
||||
if support.verbose:
|
||||
print("Test Skipped:", msg)
|
||||
# Can't raise SkipTest as regrtest only recognizes the exception
|
||||
# import time.
|
||||
return
|
||||
self.skipTest(str(msg))
|
||||
try:
|
||||
# On some systems, this map is only accessible to the
|
||||
# super user
|
||||
|
|
|
@ -218,7 +218,7 @@ def test_abspath(self):
|
|||
import nt
|
||||
tester('ntpath.abspath("C:\\")', "C:\\")
|
||||
except ImportError:
|
||||
pass
|
||||
self.skipTest('nt module not available')
|
||||
|
||||
def test_relpath(self):
|
||||
currentdir = os.path.split(os.getcwd())[-1]
|
||||
|
|
|
@ -263,7 +263,7 @@ def test_statvfs_attributes(self):
|
|||
except OSError as e:
|
||||
# On AtheOS, glibc always returns ENOSYS
|
||||
if e.errno == errno.ENOSYS:
|
||||
return
|
||||
self.skipTest('glibc always returns ENOSYS on AtheOS')
|
||||
|
||||
# Make sure direct access works
|
||||
self.assertEqual(result.f_bfree, result[3])
|
||||
|
@ -480,7 +480,7 @@ def test_1686475(self):
|
|||
os.stat(r"c:\pagefile.sys")
|
||||
except WindowsError as e:
|
||||
if e.errno == 2: # file does not exist; cannot run test
|
||||
return
|
||||
self.skipTest(r'c:\pagefile.sys does not exist')
|
||||
self.fail("Could not stat pagefile.sys")
|
||||
|
||||
@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")
|
||||
|
|
|
@ -8,8 +8,6 @@ class PwdTest(unittest.TestCase):
|
|||
|
||||
def test_values(self):
|
||||
entries = pwd.getpwall()
|
||||
entriesbyname = {}
|
||||
entriesbyuid = {}
|
||||
|
||||
for e in entries:
|
||||
self.assertEqual(len(e), 7)
|
||||
|
@ -32,13 +30,20 @@ def test_values(self):
|
|||
# for one uid
|
||||
# self.assertEqual(pwd.getpwuid(e.pw_uid), e)
|
||||
# instead of this collect all entries for one uid
|
||||
# and check afterwards
|
||||
# and check afterwards (done in test_values_extended)
|
||||
|
||||
def test_values_extended(self):
|
||||
entries = pwd.getpwall()
|
||||
entriesbyname = {}
|
||||
entriesbyuid = {}
|
||||
|
||||
if len(entries) > 1000: # Huge passwd file (NIS?) -- skip this test
|
||||
self.skipTest('passwd file is huge; extended test skipped')
|
||||
|
||||
for e in entries:
|
||||
entriesbyname.setdefault(e.pw_name, []).append(e)
|
||||
entriesbyuid.setdefault(e.pw_uid, []).append(e)
|
||||
|
||||
if len(entries) > 1000: # Huge passwd file (NIS?) -- skip the rest
|
||||
return
|
||||
|
||||
# check whether the entry returned by getpwuid()
|
||||
# for each uid is among those from getpwall() for this uid
|
||||
for e in entries:
|
||||
|
|
|
@ -166,6 +166,7 @@ def test_nesting(self):
|
|||
eq(r([[[[[[{}]]]]]]), "[[[[[[{}]]]]]]")
|
||||
eq(r([[[[[[[{}]]]]]]]), "[[[[[[[...]]]]]]]")
|
||||
|
||||
@unittest.skip('hard to catch a cell object')
|
||||
def test_cell(self):
|
||||
# XXX Hmm? How to get at a cell object?
|
||||
pass
|
||||
|
@ -272,6 +273,7 @@ class foo(object):
|
|||
eq(repr(foo.foo),
|
||||
"<class '%s.foo'>" % foo.__name__)
|
||||
|
||||
@unittest.skip('need a suitable object')
|
||||
def test_object(self):
|
||||
# XXX Test the repr of a type with a really long tp_name but with no
|
||||
# tp_repr. WIBNI we had ::Inline? :)
|
||||
|
@ -319,6 +321,7 @@ def amethod(self): pass
|
|||
'<bound method aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.amethod of <%s.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa object at 0x' \
|
||||
% (qux.__name__,) ), r)
|
||||
|
||||
@unittest.skip('needs a built-in function with a really long name')
|
||||
def test_builtin_function(self):
|
||||
# XXX test built-in functions and methods with really long names
|
||||
pass
|
||||
|
|
|
@ -752,11 +752,9 @@ def test_copytree_retains_permissions(self):
|
|||
self.assertEquals(os.stat(restrictive_subdir).st_mode,
|
||||
os.stat(restrictive_subdir_dst).st_mode)
|
||||
|
||||
@unittest.skipIf(os.name == 'nt', 'temporarily disabled on Windows')
|
||||
@unittest.skipUnless(hasattr(os, 'link'), 'requires os.link')
|
||||
def test_dont_copy_file_onto_link_to_itself(self):
|
||||
# Temporarily disable test on Windows.
|
||||
if os.name == 'nt':
|
||||
return
|
||||
# bug 851123.
|
||||
os.mkdir(TESTFN)
|
||||
src = os.path.join(TESTFN, 'cheese')
|
||||
|
|
|
@ -374,6 +374,7 @@ def test_no_duplicate_paths(self):
|
|||
self.assertNotIn(path, seen_paths)
|
||||
seen_paths.add(path)
|
||||
|
||||
@unittest.skip('test not implemented')
|
||||
def test_add_build_dir(self):
|
||||
# Test that the build directory's Modules directory is used when it
|
||||
# should be.
|
||||
|
|
|
@ -714,13 +714,13 @@ def testHostnameRes(self):
|
|||
ip = socket.gethostbyname(hostname)
|
||||
except socket.error:
|
||||
# Probably name lookup wasn't set up right; skip this test
|
||||
return
|
||||
self.skipTest('name lookup failure')
|
||||
self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
|
||||
try:
|
||||
hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
|
||||
except socket.error:
|
||||
# Probably a similar problem as above; skip this test
|
||||
return
|
||||
self.skipTest('name lookup failure')
|
||||
all_host_names = [hostname, hname] + aliases
|
||||
fqhn = socket.getfqdn(ip)
|
||||
if not fqhn in all_host_names:
|
||||
|
@ -932,9 +932,9 @@ def testIPv6toString(self):
|
|||
try:
|
||||
from socket import inet_pton, AF_INET6, has_ipv6
|
||||
if not has_ipv6:
|
||||
return
|
||||
self.skipTest('IPv6 not available')
|
||||
except ImportError:
|
||||
return
|
||||
self.skipTest('could not import needed symbols from socket')
|
||||
f = lambda a: inet_pton(AF_INET6, a)
|
||||
assertInvalid = lambda a: self.assertRaises(
|
||||
(socket.error, ValueError), f, a
|
||||
|
@ -1010,9 +1010,9 @@ def testStringToIPv6(self):
|
|||
try:
|
||||
from socket import inet_ntop, AF_INET6, has_ipv6
|
||||
if not has_ipv6:
|
||||
return
|
||||
self.skipTest('IPv6 not available')
|
||||
except ImportError:
|
||||
return
|
||||
self.skipTest('could not import needed symbols from socket')
|
||||
f = lambda a: inet_ntop(AF_INET6, a)
|
||||
assertInvalid = lambda a: self.assertRaises(
|
||||
(socket.error, ValueError), f, a
|
||||
|
@ -1045,7 +1045,7 @@ def testSockName(self):
|
|||
my_ip_addr = socket.gethostbyname(socket.gethostname())
|
||||
except socket.error:
|
||||
# Probably name lookup wasn't set up right; skip this test
|
||||
return
|
||||
self.skipTest('name lookup failure')
|
||||
self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
|
||||
self.assertEqual(name[1], port)
|
||||
|
||||
|
|
|
@ -323,7 +323,7 @@ def test_bad_timezone(self):
|
|||
# when time.tzname[0] == time.tzname[1] and time.daylight
|
||||
tz_name = time.tzname[0]
|
||||
if tz_name.upper() in ("UTC", "GMT"):
|
||||
return
|
||||
self.skipTest('need non-UTC/GMT timezone')
|
||||
try:
|
||||
original_tzname = time.tzname
|
||||
original_daylight = time.daylight
|
||||
|
@ -536,7 +536,7 @@ def test_TimeRE_recreation(self):
|
|||
try:
|
||||
locale.setlocale(locale.LC_TIME, ('en_US', 'UTF8'))
|
||||
except locale.Error:
|
||||
return
|
||||
self.skipTest('test needs en_US.UTF8 locale')
|
||||
try:
|
||||
_strptime._strptime_time('10', '%d')
|
||||
# Get id of current cache object.
|
||||
|
@ -553,7 +553,7 @@ def test_TimeRE_recreation(self):
|
|||
# If this is the case just suppress the exception and fall-through
|
||||
# to the resetting to the original locale.
|
||||
except locale.Error:
|
||||
pass
|
||||
self.skipTest('test needs de_DE.UTF8 locale')
|
||||
# Make sure we don't trample on the locale setting once we leave the
|
||||
# test.
|
||||
finally:
|
||||
|
|
|
@ -324,10 +324,9 @@ def test_choose_directory(self):
|
|||
finally:
|
||||
os.rmdir(dir)
|
||||
|
||||
@unittest.skipUnless(has_stat, 'os.stat not available')
|
||||
def test_file_mode(self):
|
||||
# _mkstemp_inner creates files with the proper mode
|
||||
if not has_stat:
|
||||
return # ugh, can't use SkipTest.
|
||||
|
||||
file = self.do_create()
|
||||
mode = stat.S_IMODE(os.stat(file.name).st_mode)
|
||||
|
@ -339,10 +338,9 @@ def test_file_mode(self):
|
|||
expected = user * (1 + 8 + 64)
|
||||
self.assertEqual(mode, expected)
|
||||
|
||||
@unittest.skipUnless(has_spawnl, 'os.spawnl not available')
|
||||
def test_noinherit(self):
|
||||
# _mkstemp_inner file handles are not inherited by child processes
|
||||
if not has_spawnl:
|
||||
return # ugh, can't use SkipTest.
|
||||
|
||||
if support.verbose:
|
||||
v="v"
|
||||
|
@ -377,10 +375,9 @@ def test_noinherit(self):
|
|||
"child process caught fatal signal %d" % -retval)
|
||||
self.assertFalse(retval > 0, "child process reports failure %d"%retval)
|
||||
|
||||
@unittest.skipUnless(has_textmode, "text mode not available")
|
||||
def test_textmode(self):
|
||||
# _mkstemp_inner can create files in text mode
|
||||
if not has_textmode:
|
||||
return # ugh, can't use SkipTest.
|
||||
|
||||
# A text file is truncated at the first Ctrl+Z byte
|
||||
f = self.do_create(bin=0)
|
||||
|
@ -556,10 +553,9 @@ def test_choose_directory(self):
|
|||
finally:
|
||||
os.rmdir(dir)
|
||||
|
||||
@unittest.skipUnless(has_stat, 'os.stat not available')
|
||||
def test_mode(self):
|
||||
# mkdtemp creates directories with the proper mode
|
||||
if not has_stat:
|
||||
return # ugh, can't use SkipTest.
|
||||
|
||||
dir = self.do_create()
|
||||
try:
|
||||
|
|
|
@ -68,39 +68,35 @@ def test_stack_size(self):
|
|||
thread.stack_size(0)
|
||||
self.assertEqual(thread.stack_size(), 0, "stack_size not reset to default")
|
||||
|
||||
if os.name not in ("nt", "os2", "posix"):
|
||||
return
|
||||
|
||||
tss_supported = True
|
||||
@unittest.skipIf(os.name not in ("nt", "os2", "posix"), 'test meant for nt, os2, and posix')
|
||||
def test_nt_and_posix_stack_size(self):
|
||||
try:
|
||||
thread.stack_size(4096)
|
||||
except ValueError:
|
||||
verbose_print("caught expected ValueError setting "
|
||||
"stack_size(4096)")
|
||||
except thread.error:
|
||||
tss_supported = False
|
||||
verbose_print("platform does not support changing thread stack "
|
||||
"size")
|
||||
self.skipTest("platform does not support changing thread stack "
|
||||
"size")
|
||||
|
||||
if tss_supported:
|
||||
fail_msg = "stack_size(%d) failed - should succeed"
|
||||
for tss in (262144, 0x100000, 0):
|
||||
thread.stack_size(tss)
|
||||
self.assertEqual(thread.stack_size(), tss, fail_msg % tss)
|
||||
verbose_print("successfully set stack_size(%d)" % tss)
|
||||
fail_msg = "stack_size(%d) failed - should succeed"
|
||||
for tss in (262144, 0x100000, 0):
|
||||
thread.stack_size(tss)
|
||||
self.assertEqual(thread.stack_size(), tss, fail_msg % tss)
|
||||
verbose_print("successfully set stack_size(%d)" % tss)
|
||||
|
||||
for tss in (262144, 0x100000):
|
||||
verbose_print("trying stack_size = (%d)" % tss)
|
||||
self.next_ident = 0
|
||||
self.created = 0
|
||||
for i in range(NUMTASKS):
|
||||
self.newtask()
|
||||
for tss in (262144, 0x100000):
|
||||
verbose_print("trying stack_size = (%d)" % tss)
|
||||
self.next_ident = 0
|
||||
self.created = 0
|
||||
for i in range(NUMTASKS):
|
||||
self.newtask()
|
||||
|
||||
verbose_print("waiting for all tasks to complete")
|
||||
self.done_mutex.acquire()
|
||||
verbose_print("all tasks done")
|
||||
verbose_print("waiting for all tasks to complete")
|
||||
self.done_mutex.acquire()
|
||||
verbose_print("all tasks done")
|
||||
|
||||
thread.stack_size(0)
|
||||
thread.stack_size(0)
|
||||
|
||||
def test__count(self):
|
||||
# Test the _count() function.
|
||||
|
|
|
@ -463,8 +463,7 @@ def test_bug_3061(self):
|
|||
try:
|
||||
tmp = locale.setlocale(locale.LC_ALL, "fr_FR")
|
||||
except locale.Error:
|
||||
# skip this test
|
||||
return
|
||||
self.skipTest('could not set locale.LC_ALL to fr_FR')
|
||||
# This should not cause an exception
|
||||
time.strftime("%B", (2009,2,1,0,0,0,0,0,0))
|
||||
|
||||
|
|
|
@ -1952,12 +1952,12 @@ def test_printable_repr(self):
|
|||
self.assertEqual(repr('\U00010000'), "'%c'" % (0x10000,)) # printable
|
||||
self.assertEqual(repr('\U00014000'), "'\\U00014000'") # nonprintable
|
||||
|
||||
# This test only affects 32-bit platforms because expandtabs can only take
|
||||
# an int as the max value, not a 64-bit C long. If expandtabs is changed
|
||||
# to take a 64-bit long, this test should apply to all platforms.
|
||||
@unittest.skipIf(sys.maxsize > (1 << 32) or struct.calcsize('P') != 4,
|
||||
'only applies to 32-bit platforms')
|
||||
def test_expandtabs_overflows_gracefully(self):
|
||||
# This test only affects 32-bit platforms because expandtabs can only take
|
||||
# an int as the max value, not a 64-bit C long. If expandtabs is changed
|
||||
# to take a 64-bit long, this test should apply to all platforms.
|
||||
if sys.maxsize > (1 << 32) or struct.calcsize('P') != 4:
|
||||
return
|
||||
self.assertRaises(OverflowError, 't\tt\t'.expandtabs, sys.maxsize)
|
||||
|
||||
@support.cpython_only
|
||||
|
|
|
@ -98,11 +98,10 @@ def test_getcode(self):
|
|||
open_url.close()
|
||||
self.assertEqual(code, 404)
|
||||
|
||||
# On Windows, socket handles are not file descriptors; this
|
||||
# test can't pass on Windows.
|
||||
@unittest.skipIf(sys.platform in ('win32',), 'not appropriate for Windows')
|
||||
def test_fileno(self):
|
||||
if sys.platform in ('win32',):
|
||||
# On Windows, socket handles are not file descriptors; this
|
||||
# test can't pass on Windows.
|
||||
return
|
||||
# Make sure fd returned by fileno is valid.
|
||||
with self.urlopen("http://www.python.org/", timeout=None) as open_url:
|
||||
fd = open_url.fileno()
|
||||
|
|
|
@ -682,7 +682,7 @@ def test_check_warnings(self):
|
|||
# Explicit tests for the test.support convenience wrapper
|
||||
wmod = self.module
|
||||
if wmod is not sys.modules['warnings']:
|
||||
return
|
||||
self.skipTest('module to test is not loaded warnings module')
|
||||
with support.check_warnings(quiet=False) as w:
|
||||
self.assertEqual(w.warnings, [])
|
||||
wmod.simplefilter("always")
|
||||
|
|
|
@ -20,7 +20,6 @@ def test_current_time(self):
|
|||
t0 = server.currentTime.getCurrentTime()
|
||||
except socket.error as e:
|
||||
self.skipTest("network error: %s" % e)
|
||||
return
|
||||
|
||||
# Perform a minimal sanity check on the result, just to be sure
|
||||
# the request means what we think it means.
|
||||
|
@ -44,7 +43,6 @@ def test_python_builders(self):
|
|||
builders = server.getAllBuilders()
|
||||
except socket.error as e:
|
||||
self.skipTest("network error: %s" % e)
|
||||
return
|
||||
self.addCleanup(lambda: server('close')())
|
||||
|
||||
# Perform a minimal sanity check on the result, just to be sure
|
||||
|
|
|
@ -111,7 +111,7 @@ def testAFakeZlib(self):
|
|||
# so we'll simply skip it then. Bug #765456.
|
||||
#
|
||||
if "zlib" in sys.builtin_module_names:
|
||||
return
|
||||
self.skipTest('zlib is a builtin module')
|
||||
if "zlib" in sys.modules:
|
||||
del sys.modules["zlib"]
|
||||
files = {"zlib.py": (NOW, test_src)}
|
||||
|
|
|
@ -109,7 +109,7 @@ Tests
|
|||
import, converting from test_main to unittest.main, and running the
|
||||
_testcapi module tests within a unittest TestCase.
|
||||
|
||||
- Issue #18702: All skipped tests now reported as skipped.
|
||||
- Issue #18702, 19572: All skipped tests now reported as skipped.
|
||||
|
||||
- Issue #19085: Added basic tests for all tkinter widget options.
|
||||
|
||||
|
|
Loading…
Reference in a new issue