Fatal Python error: Aborted FAIL: test_nonmodule_cases (test.test_importlib.extension.test_loader.NonModuleExtensionTests.test_nonmodule_cases) test_multiple_unpicklings_unseekable (test.test_pickle.PyPicklerUnpicklerObjectTests.test_multiple_unpicklings_unseekable) ... Fatal Python error: Segmentation fault ERROR: test_big_codesize (test.test_re.ReTests.test_big_codesize) Fatal Python error: Aborted ERROR: test_files (test.test_unparse.DirectoryTestCase.test_files) (code1='"""Test the datetime module."""\nimport bisect\nimport contextlib\nimport copy\nimport decimal\nimport io\nimport itertools\nimport os\nimport pickle\nimport random\nimport re\nimport struct\nimport sys\nimport textwrap\nimport unittest\nimport warnings\n\nfrom array import array\n\nfrom operator import lt, le, gt, ge, eq, ne, truediv, floordiv, mod\n\nfrom test import support\nfrom test.support import is_resource_enabled, ALWAYS_EQ, LARGEST, SMALLEST\nfrom test.support import os_helper, script_helper, warnings_helper\n\nimport datetime as datetime_module\nfrom datetime import MINYEAR, MAXYEAR\nfrom datetime import timedelta\nfrom datetime import tzinfo\nfrom datetime import time\nfrom datetime import timezone\nfrom datetime import UTC\nfrom datetime import date, datetime\nimport time as _time\n\ntry:\n import _testcapi\nexcept ImportError:\n _testcapi = None\ntry:\n import _interpreters\nexcept ModuleNotFoundError:\n _interpreters = None\n\n# Needed by test_datetime\nimport _strptime\ntry:\n import _pydatetime\nexcept ImportError:\n pass\n#\n\npickle_loads = {pickle.loads, pickle._loads}\n\npickle_choices = [(pickle, pickle, proto)\n for proto in range(pickle.HIGHEST_PROTOCOL + 1)]\nassert len(pickle_choices) == pickle.HIGHEST_PROTOCOL + 1\n\nEPOCH_NAIVE = datetime(1970, 1, 1, 0, 0) # For calculating transitions\n\n# An arbitrary collection of objects of non-datetime types, for testing\n# mixed-type comparisons.\nOTHERSTUFF = (10, 34.5, "abc", {}, [], ())\n\n# XXX Copied from test_float.\nINF = float("inf")\nNAN = float("nan")\n\n\n#############################################################################\n# module tests\n\nclass TestModule(unittest.TestCase):\n\n def test_constants(self):\n datetime = datetime_module\n self.assertEqual(datetime.MINYEAR, 1)\n self.assertEqual(datetime.MAXYEAR, 9999)\n\n def test_utc_alias(self):\n self.assertIs(UTC, timezone.utc)\n\n def test_all(self):\n """Test that __all__ only points to valid attributes."""\n all_attrs = dir(datetime_module)\n for attr in datetime_module.__all__:\n self.assertIn(attr, all_attrs)\n\n def test_name_cleanup(self):\n if \'_Pure\' in self.__class__.__name__:\n self.skipTest(\'Only run for Fast C implementation\')\n\n datetime = datetime_module\n names = set(name for name in dir(datetime)\n if not name.startswith(\'__\') and not name.endswith(\'__\'))\n allowed = set([\'MAXYEAR\', \'MINYEAR\', \'date\', \'datetime\',\n \'datetime_CAPI\', \'time\', \'timedelta\', \'timezone\',\n \'tzinfo\', \'UTC\', \'sys\'])\n self.assertEqual(names - allowed, set([]))\n\n def test_divide_and_round(self):\n if \'_Fast\' in self.__class__.__name__:\n self.skipTest(\'Only run for Pure Python implementation\')\n\n dar = _pydatetime._divide_and_round\n\n self.assertEqual(dar(-10, -3), 3)\n self.assertEqual(dar(5, -2), -2)\n\n # four cases: (2 signs of a) x (2 signs of b)\n self.assertEqual(dar(7, 3), 2)\n self.assertEqual(dar(-7, 3), -2)\n self.assertEqual(dar(7, -3), -2)\n self.assertEqual(dar(-7, -3), 2)\n\n # ties to even - eight cases:\n # (2 signs of a) x (2 signs of b) x (even / odd quotient)\n self.assertEqual(dar(10, 4), 2)\n self.assertEqual(dar(-10, 4), -2)\n self.assertEqual(dar(10, -4), -2)\n self.assertEqual(dar(-10, -4), 2)\n\n self.assertEqual(dar(6, 4), 2)\n self.assertEqual(dar(-6, 4), -2)\n self.assertEqual(dar(6, -4), -2)\n self.assertEqual(dar(-6, -4), 2)\n\n\n#############################################################################\n# tzinfo tests\n\nclass FixedOffset(tzinfo):\n\n def __init__(self, offset, name, dstoffset=42):\n if isinstance(offset, int):\n offset = timedelta(minutes=offset)\n ERROR: test_files (test.test_unparse.DirectoryTestCase.test_files) (code1='# tests common to dict and UserDict\nimport unittest\nimport collections\nfrom test import support\n\n\nclass BasicTestMappingProtocol(unittest.TestCase):\n # This base class can be used to check that an object conforms to the\n # mapping protocol\n\n # Functions that can be useful to override to adapt to dictionary\n # semantics\n type2test = None # which class is being tested (overwrite in subclasses)\n\n def _reference(self):\n """Return a dictionary of values which are invariant by storage\n in the object under test."""\n return {"1": "2", "key1":"value1", "key2":(1,2,3)}\n def _empty_mapping(self):\n """Return an empty mapping object"""\n return self.type2test()\n def _full_mapping(self, data):\n """Return a mapping object with the value contained in data\n dictionary"""\n x = self._empty_mapping()\n for key, value in data.items():\n x[key] = value\n return x\n\n def __init__(self, *args, **kw):\n unittest.TestCase.__init__(self, *args, **kw)\n self.reference = self._reference().copy()\n\n # A (key, value) pair not in the mapping\n key, value = self.reference.popitem()\n self.other = {key:value}\n\n # A (key, value) pair in the mapping\n key, value = self.reference.popitem()\n self.inmapping = {key:value}\n self.reference[key] = value\n\n def test_read(self):\n # Test for read only operations on mapping\n p = self._empty_mapping()\n p1 = dict(p) #workaround for singleton objects\n d = self._full_mapping(self.reference)\n if d is p:\n p = p1\n #Indexing\n for key, value in self.reference.items():\n self.assertEqual(d[key], value)\n knownkey = list(self.other.keys())[0]\n self.assertRaises(KeyError, lambda:d[knownkey])\n #len\n self.assertEqual(len(p), 0)\n self.assertEqual(len(d), len(self.reference))\n #__contains__\n for k in self.reference:\n self.assertIn(k, d)\n for k in self.other:\n self.assertNotIn(k, d)\n #cmp\n self.assertEqual(p, p)\n self.assertEqual(d, d)\n self.assertNotEqual(p, d)\n self.assertNotEqual(d, p)\n #bool\n if p: self.fail("Empty mapping must compare to False")\n if not d: self.fail("Full mapping must compare to True")\n # keys(), items(), iterkeys() ...\n def check_iterandlist(iter, lst, ref):\n self.assertHasAttr(iter, \'__next__\')\n self.assertHasAttr(iter, \'__iter__\')\n x = list(iter)\n self.assertTrue(set(x)==set(lst)==set(ref))\n check_iterandlist(iter(d.keys()), list(d.keys()),\n self.reference.keys())\n check_iterandlist(iter(d), list(d.keys()), self.reference.keys())\n check_iterandlist(iter(d.values()), list(d.values()),\n self.reference.values())\n check_iterandlist(iter(d.items()), list(d.items()),\n self.reference.items())\n #get\n key, value = next(iter(d.items()))\n knownkey, knownvalue = next(iter(self.other.items()))\n self.assertEqual(d.get(key, knownvalue), value)\n self.assertEqual(d.get(knownkey, knownvalue), knownvalue)\n self.assertNotIn(knownkey, d)\n\n def test_write(self):\n # Test for write operations on mapping\n p = self._empty_mapping()\n #Indexing\n for key, value in self.reference.items():\n p[key] = value\n self.assertEqual(p[key], value)\n for key in self.reference.keys():\n del p[key]\n self.assertRaises(KeyError, lambda:p[key])\n p = self._empty_mapping()\n #update\n p.update(self.reference)\n self.assertEqual(dict(p), self.reference)\n items = list(p.items())\n p = self._empty_mapping( ERROR: test_str_wrap (test.test_pprint.QueryTestCase.test_str_wrap) Fatal Python error: Aborted Re-running test_importlib in verbose mode (matching: test_nonmodule_cases) Re-running test_re in verbose mode (matching: test_big_codesize) Re-running test_sys in verbose mode Re-running test_pickle in verbose mode Re-running test_pprint in verbose mode (matching: test_str_wrap) Re-running test_queue in verbose mode Fatal Python error: Aborted Re-running test_unparse in verbose mode (matching: test_files, test_files)