from distutils import log
from distutils.tests import support
-from test.support import run_unittest
+from test.support import run_unittest, is_emscripten
class DirUtilTestCase(support.TempdirManager, unittest.TestCase):
@unittest.skipIf(sys.platform.startswith('win'),
"This test is only appropriate for POSIX-like systems.")
+ @unittest.skipIf(is_emscripten, "Emscripten's umask is a stub.")
def test_mkpath_with_custom_mode(self):
# Get and set the current umask value for testing mode bits.
umask = os.umask(0o002)
import unittest
from platform import uname
+from test import support
+
if uname().system == "Darwin":
maj, min, mic = [int(part) for part in uname().release.split(".")]
if (maj, min, mic) < (8, 0, 0):
return True
@unittest.skipUnless(nl_langinfo, "nl_langinfo is not available")
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_lc_numeric_nl_langinfo(self):
# Test nl_langinfo against known values
tested = False
if not tested:
self.skipTest('no suitable locales')
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_lc_numeric_localeconv(self):
# Test localeconv against known values
tested = False
self.assertEqual(out, 'it worked!')
- @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
+ @support.requires_fork()
def test_fork(self):
import tempfile
with tempfile.NamedTemporaryFile('w+', encoding="utf-8") as file:
gen.cr_frame.clear()
+@unittest.skipIf(
+ support.is_emscripten, "asyncio does not work under Emscripten yet."
+)
class CoroAsyncIOCompatTest(unittest.TestCase):
def test_asyncio_1(self):
import unittest
import time
+from test import support
from test.support import import_helper
_interpreters = import_helper.import_module('_xxsubinterpreters')
from test.support import interpreters
self.assertEqual(out, 'it worked!')
- @unittest.skipUnless(hasattr(os, 'fork'), "test needs os.fork()")
+ @support.requires_fork()
def test_fork(self):
interp = interpreters.create()
import tempfile
from decimal import Decimal
-from test.support import verbose, is_android
+from test.support import verbose, is_android, is_emscripten
from test.support.warnings_helper import check_warnings
import unittest
import locale
@unittest.skipIf(sys.platform.startswith('aix'),
'bpo-29972: broken test on AIX')
+ @unittest.skipIf(is_emscripten, "musl libc issue on Emscripten, bpo-46390")
def test_strcoll_with_diacritic(self):
self.assertLess(locale.strcoll('à', 'b'), 0)
@unittest.skipIf(sys.platform.startswith('aix'),
'bpo-29972: broken test on AIX')
+ @unittest.skipIf(is_emscripten, "musl libc issue on Emscripten, bpo-46390")
def test_strxfrm_with_diacritic(self):
self.assertLess(locale.strxfrm('à'), locale.strxfrm('b'))
# based on os.fork existing because that is what users and this test use.
# This helps ensure that when fork exists (the important concept) that the
# register_at_fork mechanism is also present and used.
- @unittest.skipIf(not hasattr(os, 'fork'), 'Test requires os.fork().')
+ @support.requires_fork()
def test_post_fork_child_no_deadlock(self):
"""Ensure child logging locks are not held; bpo-6721 & bpo-36533."""
class _OurHandler(logging.Handler):
return results
def test_multiprocessing(self):
+ support.skip_if_broken_multiprocessing_synchronize()
multiprocessing_imported = 'multiprocessing' in sys.modules
try:
# logMultiprocessing is True by default
import unittest
import warnings
from test.support import os_helper
-from test.support import TestFailed
+from test.support import TestFailed, is_emscripten
from test.support.os_helper import FakePath
from test import test_genericpath
from tempfile import TemporaryFile
self.assertRaises(TypeError, ntpath.commonpath,
['Program Files', b'C:\\Program Files\\Foo'])
+ @unittest.skipIf(is_emscripten, "Emscripten cannot fstat unnamed files.")
def test_sameopenfile(self):
with TemporaryFile() as tf1, TemporaryFile() as tf2:
# Make sure the same file is really the same
os.close(f)
self.assertTrue(os.access(os_helper.TESTFN, os.W_OK))
+ @unittest.skipIf(
+ support.is_emscripten, "Test is unstable under Emscripten."
+ )
def test_closerange(self):
first = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)
# We must allocate two consecutive file descriptors, otherwise
'dir5', 'dir6')
os.makedirs(path)
+ @unittest.skipIf(support.is_emscripten, "Emscripten's umask is a stub.")
def test_mode(self):
with os_helper.temp_umask(0o002):
base = os_helper.TESTFN
self.check(os.fchown, -1, -1)
@unittest.skipUnless(hasattr(os, 'fpathconf'), 'test needs os.fpathconf()')
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_fpathconf(self):
self.check(os.pathconf, "PC_NAME_MAX")
self.check(os.fpathconf, "PC_NAME_MAX")
@unittest.skipUnless(hasattr(os, 'get_blocking'),
'needs os.get_blocking() and os.set_blocking()')
+@unittest.skipIf(support.is_emscripten, "Cannot unset blocking flag")
class BlockingTests(unittest.TestCase):
def test_blocking(self):
fd = os.open(__file__, os.O_RDONLY)
self.assertEqual(times.elapsed, 0)
-@requires_os_func('fork')
+@support.requires_fork()
class ForkTests(unittest.TestCase):
def test_fork(self):
# bpo-42540: ensure os.fork() with non-default memory allocator does
from test.support import (gc_collect, bigmemtest, _2G,
cpython_only, captured_stdout,
- check_disallow_instantiation)
+ check_disallow_instantiation, is_emscripten)
import locale
import re
import sre_compile
# with ignore case.
self.assertEqual(re.fullmatch('[a-c]+', 'ABC', re.I).span(), (0, 3))
+ @unittest.skipIf(is_emscripten, "musl libc issue on Emscripten, bpo-46390")
def test_locale_caching(self):
# Issue #22410
oldlocale = locale.setlocale(locale.LC_CTYPE)
self.assertIsNone(re.match(b'(?Li)\xc5', b'\xe5'))
self.assertIsNone(re.match(b'(?Li)\xe5', b'\xc5'))
+ @unittest.skipIf(is_emscripten, "musl libc issue on Emscripten, bpo-46390")
def test_locale_compiled(self):
oldlocale = locale.setlocale(locale.LC_CTYPE)
self.addCleanup(locale.setlocale, locale.LC_CTYPE, oldlocale)
rfd, wfd, xfd)
# Issue 16230: Crash on select resized list
+ @unittest.skipIf(
+ support.is_emscripten, "Emscripten cannot select a fd multiple times."
+ )
def test_select_mutated(self):
a = []
class F:
self.assertEqual(self.LT_ins.am_pm[position], strftime_output,
"AM/PM representation in the wrong position within the tuple")
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_timezone(self):
# Make sure timezone is correct
timezone = time.strftime("%Z", self.time_tuple).lower()
self.assertEqual("Inconsistent use of : in -01:3030", str(err.exception))
@skip_if_buggy_ucrt_strfptime
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_timezone(self):
# Test timezone directives.
# When gmtime() is used with %Z, entire result of strftime() is empty.
self.assertFalse(support.match_test(test_access))
self.assertTrue(support.match_test(test_chdir))
+ @unittest.skipIf(support.is_emscripten, "Unstable in Emscripten")
def test_fd_count(self):
# We cannot test the absolute value of fd_count(): on old Linux
# kernel or glibc versions, os.urandom() keeps a FD open on
# /dev/urandom device and Python has 4 FD opens instead of 3.
+ # Test is unstable on Emscripten. The platform starts and stops
+ # background threads that use pipes and epoll fds.
start = os_helper.fd_count()
fd = os.open(__file__, os.O_RDONLY)
try:
class TestBadTempdir:
+ @unittest.skipIf(
+ support.is_emscripten, "Emscripten cannot remove write bits."
+ )
def test_read_only_directory(self):
with _inside_empty_temp_dir():
oldmode = mode = os.stat(tempfile.tempdir).st_mode
self.assertEqual(mode, expected)
@unittest.skipUnless(has_spawnl, 'os.spawnl not available')
+ @support.requires_subprocess()
def test_noinherit(self):
# _mkstemp_inner file handles are not inherited by child processes
pass
self.assertRaises(ValueError, use_closed)
+ @unittest.skipIf(
+ support.is_emscripten, "Emscripten cannot fstat renamed files."
+ )
def test_truncate_with_size_parameter(self):
# A SpooledTemporaryFile can be truncated to zero size
f = tempfile.SpooledTemporaryFile(max_size=10)
def test_asctime_bounding_check(self):
self._bounds_checking(time.asctime)
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_ctime(self):
t = time.mktime((1973, 9, 16, 1, 3, 52, 0, 0, -1))
self.assertEqual(time.ctime(t), 'Sun Sep 16 01:03:52 1973')
class TestPytime(unittest.TestCase):
@skip_if_buggy_ucrt_strfptime
@unittest.skipUnless(time._STRUCT_TM_ITEMS == 11, "needs tm_zone support")
+ @unittest.skipIf(
+ support.is_emscripten, "musl libc issue on Emscripten, bpo-46390"
+ )
def test_localtime_timezone(self):
# Get the localtime and examine it for the offset and zone.
ac_cv_func_readlinkat=no
ac_cv_func_fchmodat=no
ac_cv_func_dup3=no
+# lchmod/lchown are implemented, but fail with ENOTSUP.
+ac_cv_func_lchmod=no
+ac_cv_func_lchown=no
# Syscalls not implemented in emscripten
# [Errno 52] Function not implemented
projects / thirdparty / Python / cpython.git / commitdiff
