support define_macros / undef_macros in setup.cfg

Lib/test/test_sys.py

 import unittest, test.support
 import sys, io, os
 import struct
 import subprocess
 import textwrap
 import warnings
 import operator
 import codecs
 
 # count the number of test runs, used to create unique
@@ skipping 401 matching lines @@
         self.assertIn(0, d)
         self.assertTrue(d[0] is sys._getframe())
 
     def test_attributes(self):
         self.assertIsInstance(sys.api_version, int)
         self.assertIsInstance(sys.argv, list)
         self.assertIn(sys.byteorder, ("little", "big"))
         self.assertIsInstance(sys.builtin_module_names, tuple)
         self.assertIsInstance(sys.copyright, str)
         self.assertIsInstance(sys.exec_prefix, str)
-        self.assertIsInstance(sys.base_exec_prefix, str)
         self.assertIsInstance(sys.executable, str)
         self.assertEqual(len(sys.float_info), 11)
         self.assertEqual(sys.float_info.radix, 2)
         self.assertEqual(len(sys.int_info), 2)
         self.assertTrue(sys.int_info.bits_per_digit % 5 == 0)
         self.assertTrue(sys.int_info.sizeof_digit >= 1)
         self.assertEqual(type(sys.int_info.bits_per_digit), int)
         self.assertEqual(type(sys.int_info.sizeof_digit), int)
         self.assertIsInstance(sys.hexversion, int)
 
@@ skipping 11 matching lines @@
                 )
         self.assertIsInstance(sys.hash_info.inf, int)
         self.assertIsInstance(sys.hash_info.nan, int)
         self.assertIsInstance(sys.hash_info.imag, int)
 
         self.assertIsInstance(sys.maxsize, int)
         self.assertIsInstance(sys.maxunicode, int)
         self.assertEqual(sys.maxunicode, 0x10FFFF)
         self.assertIsInstance(sys.platform, str)
         self.assertIsInstance(sys.prefix, str)
-        self.assertIsInstance(sys.base_prefix, str)
         self.assertIsInstance(sys.version, str)
         vi = sys.version_info
         self.assertIsInstance(vi[:], tuple)
         self.assertEqual(len(vi), 5)
         self.assertIsInstance(vi[0], int)
         self.assertIsInstance(vi[1], int)
         self.assertIsInstance(vi[2], int)
         self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
         self.assertIsInstance(vi[4], int)
         self.assertIsInstance(vi.major, int)
@@ skipping 71 matching lines @@
                              stdout = subprocess.PIPE, env=env)
         out = p.communicate()[0].strip()
         self.assertEqual(out, "\xa2\n".encode("cp424"))
 
         env["PYTHONIOENCODING"] = "ascii:replace"
         p = subprocess.Popen([sys.executable, "-c", 'print(chr(0xa2))'],
                              stdout = subprocess.PIPE, env=env)
         out = p.communicate()[0].strip()
         self.assertEqual(out, b'?')
 
-    @unittest.skipIf(sys.base_prefix != sys.prefix,
-                     'Test is not venv-compatible')
     def test_executable(self):
         # sys.executable should be absolute
         self.assertEqual(os.path.abspath(sys.executable), sys.executable)
 
         # Issue #7774: Ensure that sys.executable is an empty string if argv[0]
         # has been set to an non existent program name and Python is unable to
         # retrieve the real program name
 
         # For a normal installation, it should work without 'cwd'
         # argument. For test runs in the build directory, see #7774.
@@ skipping 15 matching lines @@
 
     def test_getfilesystemencoding(self):
         fs_encoding = sys.getfilesystemencoding()
         if sys.platform == 'darwin':
             expected = 'utf-8'
         elif sys.platform == 'win32':
             expected = 'mbcs'
         else:
             expected = None
         self.check_fsencoding(fs_encoding, expected)
-
-    def test_implementation(self):
-        # This test applies to all implementations equally.
-
-        levels = {'alpha': 0xA, 'beta': 0xB, 'candidate': 0xC, 'release': 0xF}
-
-        self.assertTrue(hasattr(sys.implementation, 'name'))
-        self.assertTrue(hasattr(sys.implementation, 'version'))
-        self.assertTrue(hasattr(sys.implementation, 'hexversion'))
-        self.assertTrue(hasattr(sys.implementation, 'cache_tag'))
-
-        version = sys.implementation.version
-        self.assertEqual(version[:2], (version.major, version.minor))
-
-        hexversion = (version.major << 24 | version.minor << 16 |
-                      version.micro << 8 | levels[version.releaselevel] << 4 |
-                      version.serial << 0)
-        self.assertEqual(sys.implementation.hexversion, hexversion)
-
-        # PEP 421 requires that .name be lower case.
-        self.assertEqual(sys.implementation.name,
-                         sys.implementation.name.lower())
 
 
 class SizeofTest(unittest.TestCase):
 
     TPFLAGS_HAVE_GC = 1<<14
     TPFLAGS_HEAPTYPE = 1<<9
 
     def setUp(self):
         self.c = len(struct.pack('c', b' '))
         self.H = len(struct.pack('H', 0))
@@ skipping 178 matching lines @@
         check(reversed([]), size(h + 'lP'))
         # long
         check(0, size(vh))
         check(1, size(vh) + self.longdigit)
         check(-1, size(vh) + self.longdigit)
         PyLong_BASE = 2**sys.int_info.bits_per_digit
         check(int(PyLong_BASE), size(vh) + 2*self.longdigit)
         check(int(PyLong_BASE**2-1), size(vh) + 2*self.longdigit)
         check(int(PyLong_BASE**2), size(vh) + 3*self.longdigit)
         # memoryview
-        check(memoryview(b''), size(h + 'PPiP4P2i5P3c2P'))
+        check(memoryview(b''), size(h + 'PPiP4P2i5P3cP'))
         # module
         check(unittest, size(h + '3P'))
         # None
         check(None, size(h + ''))
         # NotImplementedType
         check(NotImplemented, size(h))
         # object
         check(object(), size(h + ''))
         # property (descriptor object)
         class C(object):
@@ skipping 112 matching lines @@
         # XXX
         # sys.flags
         check(sys.flags, size(vh) + self.P * len(sys.flags))
 
 
 def test_main():
     test.support.run_unittest(SysModuleTest, SizeofTest)
 
 if __name__ == "__main__":
     test_main()