Author: Ronan Lamy <ronan.l...@gmail.com> Branch: py3.5 Changeset: r91662:96e56ffe7aa7 Date: 2017-06-30 23:25 +0100 http://bitbucket.org/pypy/pypy/changeset/96e56ffe7aa7/
Log: hg merge default diff too long, truncating to 2000 out of 2002 lines diff --git a/lib_pypy/stackless.py b/lib_pypy/stackless.py --- a/lib_pypy/stackless.py +++ b/lib_pypy/stackless.py @@ -268,12 +268,22 @@ assert abs(d) == 1 source = getcurrent() source.tempval = arg - if d > 0: - cando = self.balance < 0 - dir = d - else: - cando = self.balance > 0 - dir = 0 + while True: + if d > 0: + cando = self.balance < 0 + dir = d + else: + cando = self.balance > 0 + dir = 0 + + if cando and self.queue[0]._tasklet_killed: + # issue #2595: the tasklet was killed while waiting. + # drop that tasklet from consideration and try again. + self.balance += d + self.queue.popleft() + else: + # normal path + break if _channel_callback is not None: _channel_callback(self, source, dir, not cando) @@ -348,6 +358,8 @@ module. """ tempval = None + _tasklet_killed = False + def __new__(cls, func=None, label=''): res = coroutine.__new__(cls) res.label = label @@ -395,6 +407,7 @@ If the exception passes the toplevel frame of the tasklet, the tasklet will silently die. """ + self._tasklet_killed = True if not self.is_zombie: # Killing the tasklet by throwing TaskletExit exception. coroutine.kill(self) diff --git a/pypy/module/cppyy/backend/create_cppyy_package.py b/pypy/module/cppyy/backend/create_cppyy_package.py new file mode 100755 --- /dev/null +++ b/pypy/module/cppyy/backend/create_cppyy_package.py @@ -0,0 +1,649 @@ +#!/usr/bin/env python +from __future__ import print_function + +import os, sys +import argparse, re, shutil, tarfile, urllib2 + + +DEBUG_TESTBUILD = False + +TARBALL_CACHE_DIR = 'releases' + +ROOT_KEEP = ['build', 'cmake', 'config', 'core', 'etc', 'interpreter', + 'io', 'LICENSE', 'net', 'Makefile', 'CMakeLists.txt', 'math', + 'main'] # main only needed in more recent root b/c of rootcling +ROOT_CORE_KEEP = ['CMakeLists.txt', 'base', 'clib', 'clingutils', 'cont', + 'dictgen', 'foundation', 'lzma', 'macosx', 'meta', + 'metacling', 'metautils', 'rootcling_stage1', 'textinput', + 'thread', 'unix', 'utils', 'winnt', 'zip'] +ROOT_IO_KEEP = ['CMakeLists.txt', 'io', 'rootpcm'] +ROOT_NET_KEEP = ['CMakeLists.txt', 'net'] +ROOT_MATH_KEEP = ['CMakeLists.txt', 'mathcore'] +ROOT_ETC_KEEP = ['Makefile.arch', 'class.rules', 'cmake', 'dictpch', + 'gdb-backtrace.sh', 'gitinfo.txt', 'helgrind-root.supp', + 'hostcert.conf', 'system.plugins-ios', + 'valgrind-root-python.supp', 'valgrind-root.supp', 'vmc'] + +ROOT_EXPLICIT_REMOVE = ['core/base/v7', 'math/mathcore/v7', 'io/io/v7'] + + +ERR_RELEASE_NOT_FOUND = 2 + + +# +## CLI arguments +# +class ReleaseValidation(argparse.Action): + def __call__(self, parser, namespace, value, option_string=None): + if not re.match(r'6\.\d\d\.\d\d', value): + raise argparse.ArgumentTypeError( + "release number should of the form '6.dd.dd'") + setattr(namespace, self.dest, value) + return value + +parser = argparse.ArgumentParser( + description='Build PyPi package for cppyy containing the minimum of ROOT') +parser.add_argument('-r', '--release', type=str, nargs='?', + action=ReleaseValidation, help='ROOT release to use') + +args = parser.parse_args() + + +# +## ROOT source pull and cleansing +# +def clean_directory(directory, keeplist, trim_cmake=True): + removed_entries = [] + for entry in os.listdir(directory): + if entry[0] == '.' or entry in keeplist: + continue + removed_entries.append(entry) + entry = os.path.join(directory, entry) + print('now removing', entry) + if os.path.isdir(entry): + shutil.rmtree(entry) + else: + os.remove(entry) + + if not trim_cmake: + return + + # now take the removed entries out of the CMakeLists.txt + if removed_entries: + inp = os.path.join(directory, 'CMakeLists.txt') + print('trimming', inp) + outp = inp+'.new' + new_cml = open(outp, 'w') + for line in open(inp).readlines(): + if ('add_subdirectory' in line) or\ + ('COMMAND' in line and 'copy' in line) or\ + ('ROOT_ADD_TEST_SUBDIRECTORY' in line) or\ + ('install(DIRECTORY' in line): + for sub in removed_entries: + if sub in line: + line = '#'+line + break + new_cml.write(line) + new_cml.close() + os.rename(outp, inp) + else: + print('reusing existing %s/CMakeLists.txt' % (directory,)) + + +class ReleaseValidation(argparse.Action): + def __call__(self, parser, namespace, value, option_string=None): + if not re.match(r'6\.\d\d\.\d\d', value): + raise argparse.ArgumentTypeError( + "release number should of the form '6.dd.dd'") + setattr(namespace, self.dest, value) + return value + +parser = argparse.ArgumentParser( + description='Build PyPi package for cppyy containing the minimum of ROOT') +parser.add_argument('-r', '--release', type=str, nargs='?', + action=ReleaseValidation, help='ROOT release to use') + +args = parser.parse_args() + +if not os.path.exists(TARBALL_CACHE_DIR): + os.mkdir(TARBALL_CACHE_DIR) + +if args.release: + # use provided release + fn = 'root_v%s.source.tar.gz' % args.release + addr = 'https://root.cern.ch/download/'+fn + if not os.path.exists(os.path.join(TARBALL_CACHE_DIR, fn)): + try: + print('retrieving', fn) + resp = urllib2.urlopen(addr, fn) + out = open(os.path.join(TARBALL_CACHE_DIR, fn), 'wb') + out.write(resp.read()) + out.close() + except urllib2.HTTPError: + print('release %s not found' % args.release) + sys.exit(ERR_RELEASE_NOT_FOUND) + else: + print('reusing', fn, 'from local directory') +else: + print('provide release ... getting latest release is not yet implemented ...') + sys.exit(1) + # get latest and set fn, args.release, etc. + +# construct version for package +args.version = '' +testnext = False +for c in args.release: + if testnext: + testnext = False + if c == '0': + continue + if c == '.': + testnext = True + args.version += c +args.version += '.0' + +fn = os.path.join(TARBALL_CACHE_DIR, fn) +pkgdir = os.path.join('root-'+args.release) +if not os.path.exists(pkgdir): + print('now extracting', args.release) + tf = tarfile.TarFile.gzopen(fn) + tf.extractall() + tf.close() +else: + print('reusing existing directory', pkgdir) + +# remove everything except for the listed set of libraries +os.chdir(pkgdir) + +clean_directory(os.path.curdir, ROOT_KEEP) +clean_directory('core', ROOT_CORE_KEEP) +clean_directory('etc', ROOT_ETC_KEEP, trim_cmake=False) +clean_directory('io', ROOT_IO_KEEP) +clean_directory('math', ROOT_MATH_KEEP) +clean_directory('net', ROOT_NET_KEEP) + + +# trim main (only need rootcling) +print('trimming main') +for entry in os.listdir('main/src'): + if entry != 'rootcling.cxx': + os.remove('main/src/'+entry) +inp = 'main/CMakeLists.txt' +outp = inp+'.new' +new_cml = open(outp, 'w') +for line in open(inp).readlines(): + if ('ROOT_EXECUTABLE' in line or\ + 'SET_TARGET_PROPERTIES' in line) and\ + not 'rootcling' in line: + line = '#'+line + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + + +# remove afterimage and ftgl explicitly +print('trimming externals') +for cmf in ['AfterImage', 'FTGL']: + os.remove('cmake/modules/Find%s.cmake' % (cmf,)) +inp = 'cmake/modules/SearchInstalledSoftware.cmake' +outp = inp+'.new' +now_stripping = False +new_cml = open(outp, 'w') +for line in open(inp).readlines(): + if '#---Check for ftgl if needed' == line[0:28] or\ + '#---Check for AfterImage' == line[0:24]: + now_stripping = True + elif '#---Check' == line[0:9]: + now_stripping = False + if now_stripping: + line = '#'+line + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + +inp = 'cmake/modules/RootBuildOptions.cmake' +outp = inp+'.new' +new_cml = open(outp, 'w') +for line in open(inp).readlines(): + if 'ROOT_BUILD_OPTION(builtin_ftgl' in line or\ + 'ROOT_BUILD_OPTION(builtin_afterimage' in line: + line = '#'+line + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + + +# remove testing and examples +print('trimming testing') +inp = 'CMakeLists.txt' +outp = inp+'.new' +now_stripping = False +new_cml = open(outp, 'w') +for line in open(inp).readlines(): + if '#---Configure Testing using CTest' == line[0:33] or\ + '#---hsimple.root' == line[0:16]: + now_stripping = True + elif '#---Packaging' == line[0:13] or\ + '#---version' == line[0:11]: + now_stripping = False + if now_stripping: + line = '#'+line + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + +print('trimming RootCPack') +inp = 'cmake/modules/RootCPack.cmake' +outp = inp+'.new' +new_cml = open(outp, 'w') +for line in open(inp): + if 'README.txt' in line: + line = '#'+line + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + +# some more explicit removes: +for dir_to_remove in ROOT_EXPLICIT_REMOVE: + try: + shutil.rmtree(dir_to_remove) + except OSError: + pass + +# special fixes +inp = 'core/base/src/TVirtualPad.cxx' +outp = inp+'.new' +new_cml = open(outp, 'w') +for line in open(inp): + if '#include "X3DBuffer.h"' == line[0:22]: + line = """//#include "X3DBuffer.h" +typedef struct _x3d_sizeof_ { + int numPoints; + int numSegs; + int numPolys; +} Size3D; +""" + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + +inp = 'math/mathcore/src/Fitter.cxx' +if os.path.exists(inp): + outp = inp+'.new' + new_cml = open(outp, 'w') + for line in open(inp): + if '#include "TF1.h"' in line: + continue + new_cml.write(line) + new_cml.close() + os.rename(outp, inp) + +# done +os.chdir(os.path.pardir) + +# debugging: run a test build +if DEBUG_TESTBUILD: + print('running a debug test build') + tb = "test_builddir" + if os.path.exists(tb): + shutil.rmtree(tb) + os.mkdir(tb) + os.chdir(tb) + os.system('cmake ../%s -DCMAKE_INSTALL_PREFIX=../install -Dminimal=ON -Dasimage=OFF' % pkgdir) + os.system('make -j 32') + + +# +## package creation +# +countdown = 0 +pidir = 'Package-'+args.release +print('creating package', pidir) +if not os.path.exists(pidir): + os.mkdir(pidir) +os.chdir(pidir); countdown += 1 + +print('creating LICENSE.txt') +with open('LICENSE.txt', 'w') as outp: + outp.write("""There are three main parts: + + LLVM: distributed under University of Illinois/NCSA Open Source License + https://opensource.org/licenses/UoI-NCSA.php + ROOT: distributed under LGPL 2.1 + https://root.cern.ch/license + Cppyy: distributed under LBNL BSD + https://fedoraproject.org/wiki/Licensing/LBNLBSD +""") + +print('creating MANIFEST.in') +with open('MANIFEST.in', 'w') as outp: + outp.write("""# Include the license file +include LICENSE.txt + +# Include the data files +recursive-include src * +""") + +print('creating README.rst') +with open('README.rst', 'w') as outp: + outp.write("""PyPy cling-support +================== + +---- + +Find the documentation here: + http://doc.pypy.org/en/latest/cppyy.html +""") + +print('creating setup.cfg') +with open('setup.cfg', 'w') as outp: + outp.write("""[bdist_wheel] +universal=0 +""") + +print('creating setup.py') +with open('setup.py', 'w') as outp: + outp.write("""import os, sys, subprocess +from setuptools import setup, find_packages +from distutils import log +from distutils.command.build import build as _build +from setuptools.command.install import install as _install +from distutils.sysconfig import get_python_lib +from distutils.errors import DistutilsSetupError +from codecs import open + +here = os.path.abspath(os.path.dirname(__file__)) +with open(os.path.join(here, 'README.rst'), encoding='utf-8') as f: + long_description = f.read() + +builddir = None +def get_builddir(): + global builddir + if builddir is None: + topdir = os.getcwd() + builddir = os.path.join(topdir, 'builddir') + return builddir + +srcdir = None +def get_srcdir(): + global srcdir + if srcdir is None: + topdir = os.getcwd() + srcdir = os.path.join(topdir, 'src', 'backend') + return srcdir + +class my_cmake_build(_build): + def __init__(self, dist, *args, **kwargs): + _build.__init__(self, dist, *args, **kwargs) + # TODO: can't seem to find a better way of getting hold of + # the install_lib parameter during the build phase ... + prefix = '' + try: + prefix = dist.get_command_obj('install').install_lib + except AttributeError: + pass + if not prefix: + prefix = get_python_lib(1, 0) + self.prefix = os.path.join(prefix, 'cppyy_backend') + + def run(self): + # base run + _build.run(self) + + # custom run + log.info('Now building libcppyy_backend.so and dependencies') + builddir = get_builddir() + srcdir = get_srcdir() + if not os.path.exists(builddir): + log.info('Creating build directory %s ...' % builddir) + os.makedirs(builddir) + + os.chdir(builddir) + log.info('Running cmake for cppyy_backend') + if subprocess.call([ + 'cmake', srcdir, '-Dminimal=ON -Dasimage=OFF', + '-DCMAKE_INSTALL_PREFIX='+self.prefix]) != 0: + raise DistutilsSetupError('Failed to configure cppyy_backend') + + nprocs = os.getenv("MAKE_NPROCS") + if nprocs: + try: + ival = int(nprocs) + nprocs = '-j'+nprocs + except ValueError: + log.warn("Integer expected for MAKE_NPROCS, but got %s (ignored)", nprocs) + nprocs = '-j1' + else: + nprocs = '-j1' + log.info('Now building cppyy_backend and dependencies ...') + if subprocess.call(['make', nprocs]) != 0: + raise DistutilsSetupError('Failed to build cppyy_backend') + + log.info('build finished') + +class my_libs_install(_install): + def run(self): + # base install + _install.run(self) + + # custom install + log.info('Now installing libcppyy_backend.so and dependencies') + builddir = get_builddir() + if not os.path.exists(builddir): + raise DistutilsSetupError('Failed to find build dir!') + os.chdir(builddir) + + prefix = self.install_lib + log.info('Now installing in %s ...', prefix) + if subprocess.call(['make', 'install']) != 0: + raise DistutilsSetupError('Failed to install cppyy_backend') + + log.info('install finished') + + def get_outputs(self): + outputs = _install.get_outputs(self) + outputs.append(os.path.join(self.install_lib, 'cppyy_backend')) + return outputs + +setup( + name='PyPy-cppyy-backend', +""") + outp.write(" version='%s', # corresponds to ROOT %s, extra number is for packager\n"\ + % (args.version, args.release)) + outp.write(""" description='Cling support for PyPy', + long_description=long_description, + + url='http://pypy.org', + + # Author details + author='PyPy Developers', + author_email='pypy-...@python.org', + + license='LLVM: UoI-NCSA; ROOT: LGPL 2.1; Cppyy: LBNL BSD', + + classifiers=[ + 'Development Status :: 4 - Beta', + + 'Intended Audience :: Developers', + + 'Topic :: Software Development', + 'Topic :: Software Development :: Interpreters', + + #'License :: OSI Approved :: MIT License', + + 'Programming Language :: Python :: 2', + 'Programming Language :: Python :: 2.7', + 'Programming Language :: Python :: Implementation :: PyPy', + 'Programming Language :: C', + 'Programming Language :: C++', + + 'Natural Language :: English' + ], + + keywords='interpreter development', + + packages=find_packages('src', ['backend']), + include_package_data=True, + + extras_require={ + }, + + cmdclass = { + 'build': my_cmake_build, + 'install': my_libs_install, + }, +) +""") + + +print('creating src ... ROOT part') +if not os.path.exists('src'): + os.mkdir('src') +os.chdir('src'); countdown += 1 +if not os.path.exists('backend'): + src = os.path.join(os.path.pardir, os.path.pardir, pkgdir) + print('now copying', src) + shutil.copytree(src, 'backend') + +print('creating src ... cppyy part') +os.chdir('backend'); countdown += 1 +if not os.path.exists('cppyy'): + os.mkdir('cppyy') + os.chdir('cppyy'); countdown += 1 + + with open('CMakeLists.txt', 'w') as outp: + outp.write("""############################################################################ +# CMakeLists.txt file for building cppyy package +############################################################################ + +ROOT_GLOB_SOURCES(sources ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cxx) +set_source_files_properties(${sources} COMPILE_FLAGS "-fomit-frame-pointer -fvisibility=hidden -DRPY_EXTERN=RPY_EXPORTED -DRPYTHON_LL2CTYPES") + +add_definitions(${CLING_CXXFLAGS}) + +ROOT_LINKER_LIBRARY(cppyy_backend ${sources} + LIBRARIES ${CMAKE_DL_LIBS} + DEPENDENCIES Core Cling RIO Thread) + +add_dependencies(cppyy_backend CLING) +""") + + os.mkdir('src') + os.chdir('src'); countdown += 1 + print('pulling cppyy/clingcwrapper.cxx from pypy') + base = 'https://bitbucket.org/pypy/pypy/raw/default/pypy/module/cppyy/' + for cppyy_file in ['src/callcontext.h', 'include/capi.h', 'src/clingcwrapper.cxx', + 'include/clingcwrapper.h', 'include/cpp_cppyy.h', 'include/cppyy.h']: + resp = urllib2.urlopen(base+cppyy_file) + with open(os.path.basename(cppyy_file), 'w') as outp: + outp.write(resp.read()) + + # fix include + inp = 'capi.h' + outp = inp+'.new' + new_cml = open(outp, 'w') + for line in open(inp).readlines(): + if 'src/precommondefs.h' in line: + line = '#include "precommondefs.h"\n' + new_cml.write(line) + new_cml.close() + os.rename(outp, inp) + + with open('precommondefs.h', 'w') as outp: + outp.write("""/***** Start of precommondefs.h *****/ + +/* This is extracted from pyconfig.h from CPython. It sets the macros + that affect the features we get from system include files. + It must not #include anything. */ + +#ifndef __PYPY_PRECOMMONDEFS_H +#define __PYPY_PRECOMMONDEFS_H + + +/* Define on Darwin to activate all library features */ +#define _DARWIN_C_SOURCE 1 +/* This must be set to 64 on some systems to enable large file support. */ +#define _FILE_OFFSET_BITS 64 +/* Define on Linux to activate all library features */ +#define _GNU_SOURCE 1 +/* This must be defined on some systems to enable large file support. */ +#define _LARGEFILE_SOURCE 1 +/* Define on NetBSD to activate all library features */ +#define _NETBSD_SOURCE 1 +/* Define to activate features from IEEE Stds 1003.1-2001 */ +#ifndef _POSIX_C_SOURCE +# define _POSIX_C_SOURCE 200112L +#endif +/* Define on FreeBSD to activate all library features */ +#define __BSD_VISIBLE 1 +#define __XSI_VISIBLE 700 +/* Windows: winsock/winsock2 mess */ +#define WIN32_LEAN_AND_MEAN +#ifdef _WIN64 + typedef __int64 Signed; + typedef unsigned __int64 Unsigned; +# define SIGNED_MIN LLONG_MIN +#else + typedef long Signed; + typedef unsigned long Unsigned; +# define SIGNED_MIN LONG_MIN +#endif + +#if !defined(RPY_ASSERT) && !defined(RPY_LL_ASSERT) && !defined(NDEBUG) +# define NDEBUG +#endif + + +/* All functions and global variables declared anywhere should use + one of the following attributes: + + RPY_EXPORTED: the symbol is exported out of libpypy-c.so. + + RPY_EXTERN: the symbol is not exported out of libpypy-c.so, but + otherwise works like 'extern' by being available to + other C sources. + + static: as usual, this means the symbol is local to this C file. + + Don't use _RPY_HIDDEN directly. For tests involving building a custom + .so, translator/tool/cbuild.py overrides RPY_EXTERN so that it becomes + equal to RPY_EXPORTED. + + Any function or global variable declared with no attribute at all is + a bug; please report or fix it. +*/ +#ifdef __GNUC__ +# define RPY_EXPORTED extern __attribute__((visibility("default"))) +# define _RPY_HIDDEN __attribute__((visibility("hidden"))) +#else +# define RPY_EXPORTED extern __declspec(dllexport) +# define _RPY_HIDDEN /* nothing */ +#endif +#ifndef RPY_EXTERN +# define RPY_EXTERN extern _RPY_HIDDEN +#endif + + +#endif /* __PYPY_PRECOMMONDEFS_H */ + +/***** End of precommondefs.h *****/ +""") + +# back up to pip package top +for i in range(countdown-1): + os.chdir(os.path.pardir) + +# add cppyy module to cmake +os.chdir('src/backend') +inp = 'CMakeLists.txt' +print('adding cppyy to cmake') +outp = inp+'.new' +new_cml = open(outp, 'w') +for line in open(inp).readlines(): + if 'add_subdirectory' in line and 'net' in line: + line += 'add_subdirectory (cppyy)\n' + new_cml.write(line) +new_cml.close() +os.rename(outp, inp) + +# done! diff --git a/pypy/module/cpyext/api.py b/pypy/module/cpyext/api.py --- a/pypy/module/cpyext/api.py +++ b/pypy/module/cpyext/api.py @@ -451,38 +451,10 @@ error=_compute_error(error, restype), gil=gil, result_borrowed=result_borrowed, result_is_ll=result_is_ll) FUNCTIONS_BY_HEADER[header][func.__name__] = api_function - - # ZZZ is this whole logic really needed??? It seems to be only - # for RPython code calling PyXxx() functions directly. I would - # think that usually directly calling the function is clean - # enough now - def unwrapper_catch(space, *args): - try: - res = unwrapper(space, *args) - except OperationError as e: - if not hasattr(unwrapper.api_func, "error_value"): - raise - state = space.fromcache(State) - state.set_exception(e) - if is_PyObject(restype): - return None - else: - return unwrapper.api_func.error_value - got_integer = isinstance(res, (int, long, float)) - if isinstance(restype, lltype.Typedef): - real_restype = restype.OF - else: - real_restype = restype - expect_integer = (isinstance(real_restype, lltype.Primitive) and - rffi.cast(restype, 0) == 0) - assert got_integer == expect_integer, ( - 'got %r not integer' % (res,)) - return res - INTERPLEVEL_API[func.__name__] = unwrapper_catch # used in tests - unwrapper = api_function.get_unwrapper() unwrapper.func = func unwrapper.api_func = api_function + INTERPLEVEL_API[func.__name__] = unwrapper # used in tests return unwrapper return decorate @@ -769,22 +741,21 @@ return space.gettypeobject(cls.typedef) check_name = "Py" + type_name + "_Check" + @cts.decl("int %s(void * obj)" % check_name, error=CANNOT_FAIL) def check(space, w_obj): "Implements the Py_Xxx_Check function" w_obj_type = space.type(w_obj) w_type = get_w_type(space) return (space.is_w(w_obj_type, w_type) or space.issubtype_w(w_obj_type, w_type)) + + @cts.decl("int %sExact(void * obj)" % check_name, error=CANNOT_FAIL) def check_exact(space, w_obj): "Implements the Py_Xxx_CheckExact function" w_obj_type = space.type(w_obj) w_type = get_w_type(space) return space.is_w(w_obj_type, w_type) - check = cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)( - func_with_new_name(check, check_name)) - check_exact = cpython_api([PyObject], rffi.INT_real, error=CANNOT_FAIL)( - func_with_new_name(check_exact, check_name + "Exact")) return check, check_exact pypy_debug_catch_fatal_exception = rffi.llexternal('pypy_debug_catch_fatal_exception', [], lltype.Void) diff --git a/pypy/module/cpyext/number.py b/pypy/module/cpyext/number.py --- a/pypy/module/cpyext/number.py +++ b/pypy/module/cpyext/number.py @@ -55,54 +55,59 @@ def func_rename(newname): return lambda func: func_with_new_name(func, newname) -def make_numbermethod(name, spacemeth): +def make_numbermethod(cname, spacemeth): @cpython_api([PyObject, PyObject], PyObject) - @func_rename('PyNumber_%s' % (name,)) + @func_rename(cname) def PyNumber_Method(space, w_o1, w_o2): meth = getattr(space, spacemeth) return meth(w_o1, w_o2) + return PyNumber_Method def make_unary_numbermethod(name, spacemeth): @cpython_api([PyObject], PyObject) - @func_rename('PyNumber_%s' % (name,)) + @func_rename(cname) def PyNumber_Method(space, w_o1): meth = getattr(space, spacemeth) return meth(w_o1) + return PyNumber_Method -def make_inplace_numbermethod(name, spacemeth): +def make_inplace_numbermethod(cname, spacemeth): spacemeth = 'inplace_' + spacemeth.rstrip('_') @cpython_api([PyObject, PyObject], PyObject) - @func_rename('PyNumber_InPlace%s' % (name,)) + @func_rename(cname) def PyNumber_Method(space, w_o1, w_o2): meth = getattr(space, spacemeth) return meth(w_o1, w_o2) + return PyNumber_Method for name, spacemeth in [ - ('Add', 'add'), - ('Subtract', 'sub'), - ('Multiply', 'mul'), - ('Divide', 'div'), - ('FloorDivide', 'floordiv'), - ('TrueDivide', 'truediv'), - ('Remainder', 'mod'), - ('Lshift', 'lshift'), - ('Rshift', 'rshift'), - ('And', 'and_'), - ('Xor', 'xor'), - ('Or', 'or_'), - ('Divmod', 'divmod'), - ('MatrixMultiply', 'matmul') - ]: - make_numbermethod(name, spacemeth) + ('Add', 'add'), + ('Subtract', 'sub'), + ('Multiply', 'mul'), + ('Divide', 'div'), + ('FloorDivide', 'floordiv'), + ('TrueDivide', 'truediv'), + ('Remainder', 'mod'), + ('Lshift', 'lshift'), + ('Rshift', 'rshift'), + ('And', 'and_'), + ('Xor', 'xor'), + ('Or', 'or_'), + ('Divmod', 'divmod'), + ('MatrixMultiply', 'matmul')]: + cname = 'PyNumber_%s' % (name,) + globals()[cname] = make_numbermethod(cname, spacemeth) if name != 'Divmod': - make_inplace_numbermethod(name, spacemeth) + cname = 'PyNumber_InPlace%s' % (name,) + globals()[cname] = make_inplace_numbermethod(cname, spacemeth) for name, spacemeth in [ - ('Negative', 'neg'), - ('Positive', 'pos'), - ('Absolute', 'abs'), - ('Invert', 'invert')]: - make_unary_numbermethod(name, spacemeth) + ('Negative', 'neg'), + ('Positive', 'pos'), + ('Absolute', 'abs'), + ('Invert', 'invert')]: + cname = 'PyNumber_%s' % (name,) + globals()[cname] = make_unary_numbermethod(cname, spacemeth) @cpython_api([PyObject, PyObject, PyObject], PyObject) def PyNumber_Power(space, w_o1, w_o2, w_o3): diff --git a/pypy/module/cpyext/test/test_floatobject.py b/pypy/module/cpyext/test/test_floatobject.py --- a/pypy/module/cpyext/test/test_floatobject.py +++ b/pypy/module/cpyext/test/test_floatobject.py @@ -95,3 +95,15 @@ Py_RETURN_NONE;"""), ]) + + def test_PyFloat_Check(self): + module = self.import_extension('foo', [ + ("test", "METH_NOARGS", + """ + PyObject* pyobj = PyFloat_FromDouble(1.0); + PyFloatObject* pfo = (PyFloatObject*)pyobj; + int res = PyFloat_Check(pyobj) && PyFloat_CheckExact(pyobj) && + PyFloat_Check(pfo) && PyFloat_CheckExact(pfo); + return PyLong_FromLong(res);"""), + ]) + assert module.test() == 1 diff --git a/pypy/module/cpyext/test/test_iterator.py b/pypy/module/cpyext/test/test_iterator.py --- a/pypy/module/cpyext/test/test_iterator.py +++ b/pypy/module/cpyext/test/test_iterator.py @@ -1,5 +1,8 @@ +import pytest +from pypy.interpreter.error import OperationError from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase +from pypy.module.cpyext.iterator import PyIter_Next class TestIterator(BaseApiTest): @@ -14,13 +17,12 @@ assert space.unwrap(api.PyIter_Next(w_iter)) == 1 assert space.unwrap(api.PyIter_Next(w_iter)) == 2 assert space.unwrap(api.PyIter_Next(w_iter)) == 3 - assert api.PyIter_Next(w_iter) is None - assert not api.PyErr_Occurred() + assert PyIter_Next(space, w_iter) is None - def test_iternext_error(self,space, api): - assert api.PyIter_Next(space.w_None) is None - assert api.PyErr_Occurred() is space.w_TypeError - api.PyErr_Clear() + def test_iternext_error(self, space): + with pytest.raises(OperationError) as excinfo: + PyIter_Next(space, space.w_None) + assert excinfo.value.w_type is space.w_TypeError class AppTestIterator(AppTestCpythonExtensionBase): diff --git a/pypy/module/cpyext/test/test_listobject.py b/pypy/module/cpyext/test/test_listobject.py --- a/pypy/module/cpyext/test/test_listobject.py +++ b/pypy/module/cpyext/test/test_listobject.py @@ -1,6 +1,8 @@ -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase from pypy.module.cpyext.pyobject import from_ref +from pypy.module.cpyext.listobject import ( + PyList_Check, PyList_CheckExact, PyList_Size) class TestListObject(BaseApiTest): def test_list(self, space, api): @@ -11,15 +13,15 @@ """) l = api.PyList_New(0) - assert api.PyList_Check(l) - assert api.PyList_CheckExact(l) + assert PyList_Check(space, l) + assert PyList_CheckExact(space, l) l = space.call_function(L) - assert api.PyList_Check(l) - assert not api.PyList_CheckExact(l) + assert PyList_Check(space, l) + assert not PyList_CheckExact(space, l) - assert not api.PyList_Check(space.newtuple([])) - assert not api.PyList_CheckExact(space.newtuple([])) + assert not PyList_Check(space, space.newtuple([])) + assert not PyList_CheckExact(space, space.newtuple([])) def test_get_size(self, space, api): l = api.PyList_New(0) @@ -27,12 +29,11 @@ api.PyList_Append(l, space.wrap(3)) assert api.PyList_GET_SIZE(l) == 1 - def test_size(self, space, api): + def test_size(self, space): l = space.newlist([space.w_None, space.w_None]) - assert api.PyList_Size(l) == 2 - assert api.PyList_Size(space.w_None) == -1 - assert api.PyErr_Occurred() is space.w_TypeError - api.PyErr_Clear() + assert PyList_Size(space, l) == 2 + with raises_w(space, TypeError): + PyList_Size(space, space.w_None) def test_insert(self, space, api): w_l = space.newlist([space.w_None, space.w_None]) diff --git a/pypy/module/cpyext/test/test_longobject.py b/pypy/module/cpyext/test/test_longobject.py --- a/pypy/module/cpyext/test/test_longobject.py +++ b/pypy/module/cpyext/test/test_longobject.py @@ -1,10 +1,14 @@ -import sys, py +import sys +import pytest +from pypy.interpreter.error import OperationError from rpython.rtyper.lltypesystem import rffi, lltype from rpython.rlib.rarithmetic import maxint from pypy.objspace.std.longobject import W_LongObject from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase - +from pypy.module.cpyext.longobject import (PyLong_Check, PyLong_CheckExact, + PyLong_FromLong, PyLong_AsLong, PyLong_AsUnsignedLong, PyLong_AsLongLong, + PyLong_AsUnsignedLongLong, PyLong_AsUnsignedLongLongMask) class TestLongObject(BaseApiTest): def test_FromLong(self, space, api): @@ -16,24 +20,25 @@ assert isinstance(w_value, W_LongObject) assert space.unwrap(w_value) == sys.maxint - def test_aslong(self, space, api): - w_value = api.PyLong_FromLong((sys.maxint - 1) / 2) + def test_aslong(self, space): + w_value = PyLong_FromLong(space, (sys.maxint - 1) / 2) assert isinstance(w_value, W_LongObject) w_value = space.mul(w_value, space.wrap(2)) assert isinstance(w_value, W_LongObject) - value = api.PyLong_AsLong(w_value) + value = PyLong_AsLong(space, w_value) assert value == (sys.maxint - 1) w_value = space.mul(w_value, space.wrap(2)) - - value = api.PyLong_AsLong(w_value) - assert value == -1 and api.PyErr_Occurred() is space.w_OverflowError - api.PyErr_Clear() - value = api.PyLong_AsUnsignedLong(w_value) + with pytest.raises(OperationError) as excinfo: + PyLong_AsLong(space, w_value) + assert excinfo.value.w_type is space.w_OverflowError + value = PyLong_AsUnsignedLong(space, w_value) assert value == (sys.maxint - 1) * 2 - self.raises(space, api, OverflowError, api.PyLong_AsUnsignedLong, space.wrap(-1)) + with pytest.raises(OperationError) as excinfo: + PyLong_AsUnsignedLong(space, space.newint(-1)) + assert excinfo.value.w_type is space.w_OverflowError def test_as_ssize_t(self, space, api): w_value = space.newlong(2) @@ -52,12 +57,12 @@ def test_type_check(self, space, api): w_l = space.wrap(sys.maxint + 1) - assert api.PyLong_Check(w_l) - assert api.PyLong_CheckExact(w_l) + assert PyLong_Check(space, w_l) + assert PyLong_CheckExact(space, w_l) w_i = space.wrap(sys.maxint) - assert api.PyLong_Check(w_i) - assert api.PyLong_CheckExact(w_i) + assert PyLong_Check(space, w_i) + assert PyLong_CheckExact(space, w_i) L = space.appexec([], """(): class L(int): @@ -65,23 +70,25 @@ return L """) l = space.call_function(L) - assert api.PyLong_Check(l) - assert not api.PyLong_CheckExact(l) + assert PyLong_Check(space, l) + assert not PyLong_CheckExact(space, l) - def test_as_longlong(self, space, api): - assert api.PyLong_AsLongLong(space.wrap(1<<62)) == 1<<62 - assert api.PyLong_AsLongLong(space.wrap(1<<63)) == -1 - api.PyErr_Clear() + def test_as_longlong(self, space): + assert PyLong_AsLongLong(space, space.wrap(1 << 62)) == 1 << 62 + with pytest.raises(OperationError) as excinfo: + PyLong_AsLongLong(space, space.wrap(1 << 63)) + assert excinfo.value.w_type is space.w_OverflowError - assert api.PyLong_AsUnsignedLongLong(space.wrap(1<<63)) == 1<<63 - assert api.PyLong_AsUnsignedLongLong(space.wrap(1<<64)) == (1<<64) - 1 - assert api.PyErr_Occurred() - api.PyErr_Clear() + assert PyLong_AsUnsignedLongLong(space, space.wrap(1 << 63)) == 1 << 63 + with pytest.raises(OperationError) as excinfo: + PyLong_AsUnsignedLongLong(space, space.wrap(1 << 64)) + assert excinfo.value.w_type is space.w_OverflowError - assert api.PyLong_AsUnsignedLongLongMask( - space.wrap(1<<64)) == 0 + assert PyLong_AsUnsignedLongLongMask(space, space.wrap(1 << 64)) == 0 - self.raises(space, api, OverflowError, api.PyLong_AsUnsignedLongLong, space.wrap(-1)) + with pytest.raises(OperationError) as excinfo: + PyLong_AsUnsignedLongLong(space, space.newint(-1)) + assert excinfo.value.w_type is space.w_OverflowError def test_as_long_and_overflow(self, space, api): overflow = lltype.malloc(rffi.CArrayPtr(rffi.INT_real).TO, 1, flavor='raw') @@ -126,10 +133,6 @@ assert api.PyLong_AsVoidPtr(w_l) == p def test_sign_and_bits(self, space, api): - if space.is_true(space.lt(space.sys.get('version_info'), - space.wrap((2, 7)))): - py.test.skip("unsupported before Python 2.7") - assert api._PyLong_Sign(space.wraplong(0L)) == 0 assert api._PyLong_Sign(space.wraplong(2L)) == 1 assert api._PyLong_Sign(space.wraplong(-2L)) == -1 @@ -328,6 +331,6 @@ ret = PyLong_FromLong(-1); Py_DECREF(obj); return ret; - """),]) + """)]) assert module.has_sub() == 0 assert module.has_pow() == 0 diff --git a/pypy/module/cpyext/test/test_module.py b/pypy/module/cpyext/test/test_module.py --- a/pypy/module/cpyext/test/test_module.py +++ b/pypy/module/cpyext/test/test_module.py @@ -1,4 +1,6 @@ -from pypy.module.cpyext.modsupport import PyModule_New +import pytest +from pypy.interpreter.error import OperationError +from pypy.module.cpyext.modsupport import PyModule_New, PyModule_GetName from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase from rpython.rtyper.lltypesystem import rffi @@ -11,13 +13,15 @@ assert space.eq_w(space.getattr(w_mod, space.newtext('__name__')), space.newtext('testname')) - def test_module_getname(self, space, api): + def test_module_getname(self, space): w_sys = space.wrap(space.sys) - p = api.PyModule_GetName(w_sys) + p = PyModule_GetName(space, w_sys) assert rffi.charp2str(p) == 'sys' - p2 = api.PyModule_GetName(w_sys) + p2 = PyModule_GetName(space, w_sys) assert p2 == p - self.raises(space, api, SystemError, api.PyModule_GetName, space.w_True) + with pytest.raises(OperationError) as excinfo: + PyModule_GetName(space, space.w_True) + assert excinfo.value.w_type is space.w_SystemError class AppTestModuleObject(AppTestCpythonExtensionBase): diff --git a/pypy/module/cpyext/test/test_ndarrayobject.py b/pypy/module/cpyext/test/test_ndarrayobject.py --- a/pypy/module/cpyext/test/test_ndarrayobject.py +++ b/pypy/module/cpyext/test/test_ndarrayobject.py @@ -1,13 +1,16 @@ -import py +import pytest import os +from pypy.interpreter.error import OperationError from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase from rpython.rtyper.lltypesystem import rffi, lltype from pypy.module.micronumpy.ndarray import W_NDimArray from pypy.module.micronumpy.descriptor import get_dtype_cache import pypy.module.micronumpy.constants as NPY +from pypy.module.cpyext.ndarrayobject import ( + _PyArray_FromAny, _PyArray_FromObject) -py.test.skip("Micronumpy not yet supported on py3k.") +pytest.skip("Micronumpy not yet supported on py3k.") def scalar(space): dtype = get_dtype_cache(space).w_float64dtype @@ -89,19 +92,19 @@ ptr = rffi.cast(rffi.DOUBLEP, api._PyArray_DATA(a)) assert ptr[0] == 10. - def test_FromAny(self, space, api): + def test_FromAny(self, space): a = array(space, [10, 5, 3]) - assert api._PyArray_FromAny(a, None, 0, 0, 0, NULL) is a - assert api._PyArray_FromAny(a, None, 1, 4, 0, NULL) is a - self.raises(space, api, ValueError, api._PyArray_FromAny, - a, None, 4, 5, 0, NULL) + assert _PyArray_FromAny(space, a, None, 0, 0, 0, NULL) is a + assert _PyArray_FromAny(space, a, None, 1, 4, 0, NULL) is a + with pytest.raises(OperationError) as excinfo: + _PyArray_FromAny(space, a, None, 4, 5, 0, NULL) - def test_FromObject(self, space, api): + def test_FromObject(self, space): a = array(space, [10, 5, 3]) - assert api._PyArray_FromObject(a, a.get_dtype().num, 0, 0) is a - exc = self.raises(space, api, ValueError, api._PyArray_FromObject, - a, 11, 4, 5) - assert exc.errorstr(space).find('desired') >= 0 + assert _PyArray_FromObject(space, a, a.get_dtype().num, 0, 0) is a + with pytest.raises(OperationError) as excinfo: + _PyArray_FromObject(space, a, 11, 4, 5) + assert excinfo.value.errorstr(space).find('desired') >= 0 def test_list_from_fixedptr(self, space, api): A = lltype.GcArray(lltype.Float) @@ -218,7 +221,7 @@ assert res.get_scalar_value().imag == 4. def _test_Ufunc_FromFuncAndDataAndSignature(self, space, api): - py.test.skip('preliminary non-translated test') + pytest.skip('preliminary non-translated test') ''' PyUFuncGenericFunction funcs[] = {&double_times2, &int_times2}; char types[] = { NPY_DOUBLE,NPY_DOUBLE, NPY_INT, NPY_INT }; @@ -365,7 +368,7 @@ def test_ufunc(self): if self.runappdirect: from numpy import arange - py.test.xfail('segfaults on cpython: PyUFunc_API == NULL?') + pytest.xfail('segfaults on cpython: PyUFunc_API == NULL?') else: from _numpypy.multiarray import arange mod = self.import_extension('foo', [ diff --git a/pypy/module/cpyext/test/test_number.py b/pypy/module/cpyext/test/test_number.py --- a/pypy/module/cpyext/test/test_number.py +++ b/pypy/module/cpyext/test/test_number.py @@ -1,68 +1,77 @@ +import pytest from rpython.rtyper.lltypesystem import lltype +from pypy.interpreter.error import OperationError from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase +from pypy.module.cpyext.number import ( + PyIndex_Check, PyNumber_Check, PyNumber_Long, + PyNumber_Index, PyNumber_Add, + PyNumber_Multiply, PyNumber_InPlaceMultiply, PyNumber_Absolute, + PyNumber_Power, PyNumber_InPlacePower) +from pypy.module.cpyext.floatobject import PyFloat_Check +from pypy.module.cpyext.longobject import PyLong_CheckExact +from pypy.module.cpyext.object import PyObject_Size class TestIterator(BaseApiTest): - def test_check(self, space, api): - assert api.PyIndex_Check(space.wrap(12)) - assert api.PyIndex_Check(space.wraplong(-12L)) - assert not api.PyIndex_Check(space.wrap(12.1)) - assert not api.PyIndex_Check(space.wrap('12')) + def test_check(self, space): + assert PyIndex_Check(space, space.wrap(12)) + assert PyIndex_Check(space, space.wraplong(-12L)) + assert not PyIndex_Check(space, space.wrap(12.1)) + assert not PyIndex_Check(space, space.wrap('12')) - assert api.PyNumber_Check(space.wrap(12)) - assert api.PyNumber_Check(space.wraplong(-12L)) - assert api.PyNumber_Check(space.wrap(12.1)) - assert not api.PyNumber_Check(space.wrap('12')) - assert api.PyNumber_Check(space.wrap(1+3j)) + assert PyNumber_Check(space, space.wrap(12)) + assert PyNumber_Check(space, space.wraplong(-12L)) + assert PyNumber_Check(space, space.wrap(12.1)) + assert not PyNumber_Check(space, space.wrap('12')) + assert PyNumber_Check(space, space.wrap(1 + 3j)) - def test_number_long(self, space, api): - w_l = api.PyNumber_Long(space.wrap(123)) - assert api.PyLong_CheckExact(w_l) - w_l = api.PyNumber_Long(space.wrap("123")) - assert api.PyLong_CheckExact(w_l) + def test_number_long(self, space): + w_l = PyNumber_Long(space, space.wrap(123)) + assert PyLong_CheckExact(space, w_l) + w_l = PyNumber_Long(space, space.wrap("123")) + assert PyLong_CheckExact(space, w_l) - def test_number_long2(self, space, api): - w_l = api.PyNumber_Long(space.wraplong(123L)) - assert api.PyLong_CheckExact(w_l) - w_l = api.PyNumber_Long(space.wrap(2 << 65)) - assert api.PyLong_CheckExact(w_l) - w_l = api.PyNumber_Long(space.wrap(42.3)) - assert api.PyLong_CheckExact(w_l) - w_l = api.PyNumber_Long(space.wrap("42")) - assert api.PyLong_CheckExact(w_l) + def test_number_long2(self, space): + w_l = PyNumber_Long(space, space.wraplong(123L)) + assert PyLong_CheckExact(space, w_l) + w_l = PyNumber_Long(space, space.wrap(2 << 65)) + assert PyLong_CheckExact(space, w_l) + w_l = PyNumber_Long(space, space.wrap(42.3)) + assert PyLong_CheckExact(space, w_l) + w_l = PyNumber_Long(space, space.wrap("42")) + assert PyLong_CheckExact(space, w_l) - def test_number_index(self, space, api): - w_l = api.PyNumber_Index(space.wraplong(123L)) - assert api.PyLong_CheckExact(w_l) - w_l = api.PyNumber_Index(space.wrap(42.3)) - assert w_l is None - api.PyErr_Clear() + def test_number_index(self, space): + w_l = PyNumber_Index(space, space.wraplong(123L)) + assert PyLong_CheckExact(space, w_l) + with pytest.raises(OperationError): + PyNumber_Index(space, space.wrap(42.3)) def test_numbermethods(self, space, api): assert "ab" == space.unwrap( - api.PyNumber_Add(space.wrap("a"), space.wrap("b"))) + PyNumber_Add(space, space.wrap("a"), space.wrap("b"))) assert "aaa" == space.unwrap( - api.PyNumber_Multiply(space.wrap("a"), space.wrap(3))) + PyNumber_Multiply(space, space.wrap("a"), space.wrap(3))) w_l = space.newlist([1, 2, 3]) - w_l2 = api.PyNumber_Multiply(w_l, space.wrap(3)) - assert api.PyObject_Size(w_l2) == 9 - assert api.PyObject_Size(w_l) == 3 + w_l2 = PyNumber_Multiply(space, w_l, space.wrap(3)) + assert PyObject_Size(space, w_l2) == 9 + assert PyObject_Size(space, w_l) == 3 - w_l3 = api.PyNumber_InPlaceMultiply(w_l, space.wrap(3)) - assert api.PyObject_Size(w_l) == 9 + w_l3 = PyNumber_InPlaceMultiply(space, w_l, space.wrap(3)) + assert PyObject_Size(space, w_l) == 9 assert w_l3 is w_l # unary function - assert 9 == space.unwrap(api.PyNumber_Absolute(space.wrap(-9))) + assert 9 == space.unwrap(PyNumber_Absolute(space, space.wrap(-9))) # power assert 9 == space.unwrap( - api.PyNumber_Power(space.wrap(3), space.wrap(2), space.w_None)) + PyNumber_Power(space, space.wrap(3), space.wrap(2), space.w_None)) assert 4 == space.unwrap( - api.PyNumber_Power(space.wrap(3), space.wrap(2), space.wrap(5))) + PyNumber_Power(space, space.wrap(3), space.wrap(2), space.wrap(5))) assert 9 == space.unwrap( - api.PyNumber_InPlacePower(space.wrap(3), space.wrap(2), space.w_None)) + PyNumber_InPlacePower(space, space.wrap(3), space.wrap(2), space.w_None)) class AppTestCNumber(AppTestCpythonExtensionBase): diff --git a/pypy/module/cpyext/test/test_object.py b/pypy/module/cpyext/test/test_object.py --- a/pypy/module/cpyext/test/test_object.py +++ b/pypy/module/cpyext/test/test_object.py @@ -1,10 +1,16 @@ -import py, pytest +import pytest -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase -from rpython.rtyper.lltypesystem import rffi, lltype +from rpython.rtyper.lltypesystem import rffi from pypy.module.cpyext.api import ( Py_LT, Py_LE, Py_NE, Py_EQ, Py_GE, Py_GT) +from pypy.module.cpyext.object import ( + PyObject_IsTrue, PyObject_Not, PyObject_GetAttrString, + PyObject_DelAttrString, PyObject_GetAttr, PyObject_DelAttr, + PyObject_GetItem, PyObject_RichCompareBool, + PyObject_IsInstance, PyObject_IsSubclass, PyObject_AsFileDescriptor, + PyObject_Hash) class TestObject(BaseApiTest): def test_IsTrue(self, space, api): @@ -25,9 +31,10 @@ raise ValueError return C()""") - assert api.PyObject_IsTrue(w_obj) == -1 - assert api.PyObject_Not(w_obj) == -1 - api.PyErr_Clear() + with raises_w(space, ValueError): + PyObject_IsTrue(space, w_obj) + with raises_w(space, ValueError): + PyObject_Not(space, w_obj) def test_HasAttr(self, space, api): hasattr_ = lambda w_obj, name: api.PyObject_HasAttr(w_obj, @@ -59,22 +66,21 @@ rffi.free_charp(buf) assert space.unwrap(space.getattr(w_obj, space.wrap('test'))) == 20 - def test_getattr(self, space, api): + def test_getattr(self, space): charp1 = rffi.str2charp("__len__") charp2 = rffi.str2charp("not_real") - assert api.PyObject_GetAttrString(space.wrap(""), charp1) - assert not api.PyObject_GetAttrString(space.wrap(""), charp2) - assert api.PyErr_Occurred() is space.w_AttributeError - api.PyErr_Clear() - assert api.PyObject_DelAttrString(space.wrap(""), charp1) == -1 - assert api.PyErr_Occurred() is space.w_AttributeError - api.PyErr_Clear() + assert PyObject_GetAttrString(space, space.wrap(""), charp1) + + with raises_w(space, AttributeError): + PyObject_GetAttrString(space, space.wrap(""), charp2) + with raises_w(space, AttributeError): + PyObject_DelAttrString(space, space.wrap(""), charp1) rffi.free_charp(charp1) rffi.free_charp(charp2) - assert api.PyObject_GetAttr(space.wrap(""), space.wrap("__len__")) - assert api.PyObject_DelAttr(space.wrap(""), space.wrap("__len__")) == -1 - api.PyErr_Clear() + assert PyObject_GetAttr(space, space.wrap(""), space.wrap("__len__")) + with raises_w(space, AttributeError): + PyObject_DelAttr(space, space.wrap(""), space.wrap("__len__")) def test_getitem(self, space, api): w_t = space.wrap((1, 2, 3, 4, 5)) @@ -88,9 +94,8 @@ assert space.getitem(w_d, space.wrap("key")) is space.w_None assert api.PyObject_DelItem(w_d, space.wrap("key")) == 0 - assert api.PyObject_GetItem(w_d, space.wrap("key")) is None - assert api.PyErr_Occurred() is space.w_KeyError - api.PyErr_Clear() + with raises_w(space, KeyError): + PyObject_GetItem(space, w_d, space.wrap("key")) def test_size(self, space, api): assert api.PyObject_Size(space.newlist([space.w_None])) == 1 @@ -119,9 +124,9 @@ w_o2 = space.wrap(o2) for opid, expected in [ - (Py_LT, o1 < o2), (Py_LE, o1 <= o2), + (Py_LT, o1 < o2), (Py_LE, o1 <= o2), (Py_NE, o1 != o2), (Py_EQ, o1 == o2), - (Py_GT, o1 > o2), (Py_GE, o1 >= o2)]: + (Py_GT, o1 > o2), (Py_GE, o1 >= o2)]: assert compare(w_o1, w_o2, opid) == expected test_compare(1, 2) @@ -129,9 +134,8 @@ test_compare('2', '1') w_i = space.wrap(1) - assert api.PyObject_RichCompareBool(w_i, w_i, 123456) == -1 - assert api.PyErr_Occurred() is space.w_SystemError - api.PyErr_Clear() + with raises_w(space, SystemError): + PyObject_RichCompareBool(space, w_i, w_i, 123456) def test_IsInstance(self, space, api): assert api.PyObject_IsInstance(space.wrap(1), space.w_int) == 1 @@ -140,8 +144,8 @@ assert api.PyObject_IsInstance( space.wrap(1), space.newtuple([space.w_int, space.w_float])) == 1 assert api.PyObject_IsInstance(space.w_type, space.w_type) == 1 - assert api.PyObject_IsInstance(space.wrap(1), space.w_None) == -1 - api.PyErr_Clear() + with raises_w(space, TypeError): + PyObject_IsInstance(space, space.wrap(1), space.w_None) def test_IsSubclass(self, space, api): assert api.PyObject_IsSubclass(space.w_type, space.w_type) == 1 @@ -149,14 +153,13 @@ assert api.PyObject_IsSubclass(space.w_object, space.w_type) == 0 assert api.PyObject_IsSubclass( space.w_type, space.newtuple([space.w_int, space.w_type])) == 1 - assert api.PyObject_IsSubclass(space.wrap(1), space.w_type) == -1 - api.PyErr_Clear() + with raises_w(space, TypeError): + PyObject_IsSubclass(space, space.wrap(1), space.w_type) def test_fileno(self, space, api): assert api.PyObject_AsFileDescriptor(space.wrap(1)) == 1 - assert api.PyObject_AsFileDescriptor(space.wrap(-20)) == -1 - assert api.PyErr_Occurred() is space.w_ValueError - api.PyErr_Clear() + with raises_w(space, ValueError): + PyObject_AsFileDescriptor(space, space.wrap(-20)) w_File = space.appexec([], """(): class File: @@ -169,9 +172,8 @@ def test_hash(self, space, api): assert api.PyObject_Hash(space.wrap(72)) == 72 assert api.PyObject_Hash(space.wrap(-1)) == -2 - assert (api.PyObject_Hash(space.wrap([])) == -1 and - api.PyErr_Occurred() is space.w_TypeError) - api.PyErr_Clear() + with raises_w(space, TypeError): + PyObject_Hash(space, space.wrap([])) def test_hash_double(self, space, api): assert api._Py_HashDouble(72.0) == 72 @@ -195,7 +197,7 @@ from pypy.interpreter import gateway AppTestCpythonExtensionBase.setup_class.im_func(cls) - tmpname = str(py.test.ensuretemp('out', dir=0)) + tmpname = str(pytest.ensuretemp('out', dir=0)) cls.w_tmpname = cls.space.wrap(tmpname) if not cls.runappdirect: diff --git a/pypy/module/cpyext/test/test_pyerrors.py b/pypy/module/cpyext/test/test_pyerrors.py --- a/pypy/module/cpyext/test/test_pyerrors.py +++ b/pypy/module/cpyext/test/test_pyerrors.py @@ -5,9 +5,7 @@ from pypy.module.cpyext.state import State from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase -from rpython.rtyper.lltypesystem import rffi, ll2ctypes - -from pypy.interpreter.gateway import interp2app +from rpython.rtyper.lltypesystem import rffi class TestExceptions(BaseApiTest): def test_GivenExceptionMatches(self, space, api): @@ -61,13 +59,6 @@ assert space.eq_w(state.operror.w_type, space.w_MemoryError) api.PyErr_Clear() - def test_BadArgument(self, space, api): - ret = api.PyErr_BadArgument() - state = space.fromcache(State) - assert space.eq_w(state.operror.w_type, space.w_TypeError) - assert ret == 0 - api.PyErr_Clear() - def test_Warning(self, space, api, capfd): message = rffi.str2charp("this is a warning") api.PyErr_WarnEx(None, message, 1) diff --git a/pypy/module/cpyext/test/test_pyfile.py b/pypy/module/cpyext/test/test_pyfile.py --- a/pypy/module/cpyext/test/test_pyfile.py +++ b/pypy/module/cpyext/test/test_pyfile.py @@ -1,8 +1,8 @@ +import pytest from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.object import Py_PRINT_RAW from rpython.rtyper.lltypesystem import rffi from rpython.tool.udir import udir -import pytest class TestFile(BaseApiTest): diff --git a/pypy/module/cpyext/test/test_pystrtod.py b/pypy/module/cpyext/test/test_pystrtod.py --- a/pypy/module/cpyext/test/test_pystrtod.py +++ b/pypy/module/cpyext/test/test_pystrtod.py @@ -1,67 +1,62 @@ import math from pypy.module.cpyext import pystrtod -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w from rpython.rtyper.lltypesystem import rffi from rpython.rtyper.lltypesystem import lltype +from pypy.module.cpyext.pystrtod import PyOS_string_to_double class TestPyOS_string_to_double(BaseApiTest): - def test_simple_float(self, api): + def test_simple_float(self, space): s = rffi.str2charp('0.4') null = lltype.nullptr(rffi.CCHARPP.TO) - r = api.PyOS_string_to_double(s, null, None) + r = PyOS_string_to_double(space, s, null, None) assert r == 0.4 rffi.free_charp(s) - def test_empty_string(self, api): + def test_empty_string(self, space): s = rffi.str2charp('') null = lltype.nullptr(rffi.CCHARPP.TO) - r = api.PyOS_string_to_double(s, null, None) - assert r == -1.0 - raises(ValueError) - api.PyErr_Clear() + with raises_w(space, ValueError): + PyOS_string_to_double(space, s, null, None) rffi.free_charp(s) - def test_bad_string(self, api): + def test_bad_string(self, space): s = rffi.str2charp(' 0.4') null = lltype.nullptr(rffi.CCHARPP.TO) - r = api.PyOS_string_to_double(s, null, None) - assert r == -1.0 - raises(ValueError) - api.PyErr_Clear() + with raises_w(space, ValueError): + PyOS_string_to_double(space, s, null, None) rffi.free_charp(s) - def test_overflow_pos(self, api): + def test_overflow_pos(self, space): s = rffi.str2charp('1e500') null = lltype.nullptr(rffi.CCHARPP.TO) - r = api.PyOS_string_to_double(s, null, None) + r = PyOS_string_to_double(space, s, null, None) assert math.isinf(r) assert r > 0 rffi.free_charp(s) - def test_overflow_neg(self, api): + def test_overflow_neg(self, space): s = rffi.str2charp('-1e500') null = lltype.nullptr(rffi.CCHARPP.TO) - r = api.PyOS_string_to_double(s, null, None) + r = PyOS_string_to_double(space, s, null, None) assert math.isinf(r) assert r < 0 rffi.free_charp(s) - def test_overflow_exc(self, space, api): + def test_overflow_exc(self, space): s = rffi.str2charp('1e500') null = lltype.nullptr(rffi.CCHARPP.TO) - r = api.PyOS_string_to_double(s, null, space.w_ValueError) - assert r == -1.0 - raises(ValueError) - api.PyErr_Clear() + with raises_w(space, ValueError): + PyOS_string_to_double(space, s, null, space.w_ValueError) rffi.free_charp(s) - def test_endptr_number(self, api): + def test_endptr_number(self, space): s = rffi.str2charp('0.4') endp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') - r = api.PyOS_string_to_double(s, endp, None) + r = PyOS_string_to_double(space, s, endp, None) assert r == 0.4 endp_addr = rffi.cast(rffi.LONG, endp[0]) s_addr = rffi.cast(rffi.LONG, s) @@ -69,10 +64,10 @@ rffi.free_charp(s) lltype.free(endp, flavor='raw') - def test_endptr_tail(self, api): + def test_endptr_tail(self, space): s = rffi.str2charp('0.4 foo') endp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') - r = api.PyOS_string_to_double(s, endp, None) + r = PyOS_string_to_double(space, s, endp, None) assert r == 0.4 endp_addr = rffi.cast(rffi.LONG, endp[0]) s_addr = rffi.cast(rffi.LONG, s) @@ -80,16 +75,14 @@ rffi.free_charp(s) lltype.free(endp, flavor='raw') - def test_endptr_no_conversion(self, api): + def test_endptr_no_conversion(self, space): s = rffi.str2charp('foo') endp = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') - r = api.PyOS_string_to_double(s, endp, None) - assert r == -1.0 - raises(ValueError) + with raises_w(space, ValueError): + PyOS_string_to_double(space, s, endp, None) endp_addr = rffi.cast(rffi.LONG, endp[0]) s_addr = rffi.cast(rffi.LONG, s) assert endp_addr == s_addr - api.PyErr_Clear() rffi.free_charp(s) lltype.free(endp, flavor='raw') @@ -164,4 +157,4 @@ r = api.PyOS_double_to_string(3.14, 'g', 3, 0, ptype) assert '3.14' == rffi.charp2str(r) assert ptype == lltype.nullptr(rffi.INTP.TO) - rffi.free_charp(r) \ No newline at end of file + rffi.free_charp(r) diff --git a/pypy/module/cpyext/test/test_sequence.py b/pypy/module/cpyext/test/test_sequence.py --- a/pypy/module/cpyext/test/test_sequence.py +++ b/pypy/module/cpyext/test/test_sequence.py @@ -1,9 +1,12 @@ -from rpython.rtyper.lltypesystem import rffi, lltype +from rpython.rtyper.lltypesystem import rffi from pypy.interpreter.error import OperationError -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase -from pypy.module.cpyext import sequence -import py.test +from pypy.module.cpyext.sequence import ( + PySequence_Fast, PySequence_Contains, PySequence_Index, + PySequence_GetItem, PySequence_SetItem, PySequence_DelItem) + +import pytest class TestSequence(BaseApiTest): def test_check(self, space, api): @@ -56,16 +59,12 @@ w_t2 = api.PySequence_InPlaceRepeat(w_t1, 3) assert space.unwrap(w_t2) == [0, 1, 0, 1, 0, 1] - def test_exception(self, space, api): + def test_exception(self, space): message = rffi.str2charp("message") - assert not api.PySequence_Fast(space.wrap(3), message) - assert api.PyErr_Occurred() is space.w_TypeError - api.PyErr_Clear() - - exc = raises(OperationError, sequence.PySequence_Fast, - space, space.wrap(3), message) - assert exc.value.match(space, space.w_TypeError) - assert space.str_w(exc.value.get_w_value(space)) == "message" + with pytest.raises(OperationError) as excinfo: + PySequence_Fast(space, space.wrap(3), message) + assert excinfo.value.match(space, space.w_TypeError) + assert space.str_w(excinfo.value.get_w_value(space)) == "message" rffi.free_charp(message) def test_get_slice(self, space, api): @@ -80,7 +79,7 @@ def test_get_slice_fast(self, space, api): w_t = space.wrap([1, 2, 3, 4, 5]) - api.PySequence_Fast(w_t, "foo") # converts + api.PySequence_Fast(w_t, "foo") # converts assert space.unwrap(api.PySequence_GetSlice(w_t, 2, 4)) == [3, 4] assert space.unwrap(api.PySequence_GetSlice(w_t, 1, -1)) == [2, 3, 4] @@ -97,13 +96,12 @@ exc = raises(OperationError, space.next, w_iter) assert exc.value.match(space, space.w_StopIteration) - def test_contains(self, space, api): + def test_contains(self, space): w_t = space.wrap((1, 'ha')) - assert api.PySequence_Contains(w_t, space.wrap(u'ha')) - assert not api.PySequence_Contains(w_t, space.wrap(2)) - assert api.PySequence_Contains(space.w_None, space.wrap(2)) == -1 - assert api.PyErr_Occurred() - api.PyErr_Clear() + assert PySequence_Contains(space, w_t, space.wrap(u'ha')) + assert not PySequence_Contains(space, w_t, space.wrap(2)) + with raises_w(space, TypeError): + PySequence_Contains(space, space.w_None, space.wrap(2)) def test_setitem(self, space, api): w_value = space.wrap(42) @@ -112,39 +110,33 @@ result = api.PySequence_SetItem(l, 0, w_value) assert result != -1 assert space.eq_w(space.getitem(l, space.wrap(0)), w_value) - - self.raises(space, api, IndexError, api.PySequence_SetItem, - l, 3, w_value) + with raises_w(space, IndexError): + PySequence_SetItem(space, l, 3, w_value) t = api.PyTuple_New(1) api.PyTuple_SetItem(t, 0, l) - self.raises(space, api, TypeError, api.PySequence_SetItem, - t, 0, w_value) - - self.raises(space, api, TypeError, api.PySequence_SetItem, - space.newdict(), 0, w_value) + with raises_w(space, TypeError): + PySequence_SetItem(space, t, 0, w_value) + with raises_w(space, TypeError): + PySequence_SetItem(space, space.newdict(), 0, w_value) def test_delitem(self, space, api): w_l = space.wrap([1, 2, 3, 4]) - result = api.PySequence_DelItem(w_l, 2) assert result == 0 assert space.eq_w(w_l, space.wrap([1, 2, 4])) - - self.raises(space, api, IndexError, api.PySequence_DelItem, - w_l, 3) + with raises_w(space, IndexError): + PySequence_DelItem(space, w_l, 3) def test_getitem(self, space, api): thelist = [8, 7, 6, 5, 4, 3, 2, 1] w_l = space.wrap(thelist) - result = api.PySequence_GetItem(w_l, 4) assert space.is_true(space.eq(result, space.wrap(4))) - result = api.PySequence_ITEM(w_l, 4) assert space.is_true(space.eq(result, space.wrap(4))) - - self.raises(space, api, IndexError, api.PySequence_GetItem, w_l, 9000) + with raises_w(space, IndexError): + PySequence_GetItem(space, w_l, 9000) def test_index(self, space, api): thelist = [9, 8, 7, 6, 5, 4, 3, 2, 1] @@ -155,10 +147,8 @@ assert result == thelist.index(5) w_tofind = space.wrap(9001) - result = api.PySequence_Index(w_l, w_tofind) - assert result == -1 - assert api.PyErr_Occurred() is space.w_ValueError - api.PyErr_Clear() + with raises_w(space, ValueError): + PySequence_Index(space, w_l, w_tofind) w_gen = space.appexec([], """(): return (x ** 2 for x in range(40))""") @@ -196,7 +186,7 @@ assert space.int_w(space.len(w_l)) == 4 assert space.int_w(space.getitem(w_l, space.wrap(1))) == 2 assert space.int_w(space.getitem(w_l, space.wrap(0))) == 1 - e = py.test.raises(OperationError, space.getitem, w_l, space.wrap(15)) + e = pytest.raises(OperationError, space.getitem, w_l, space.wrap(15)) assert "list index out of range" in e.value.errorstr(space) assert space.int_w(space.getitem(w_l, space.wrap(-1))) == 4 space.setitem(w_l, space.wrap(1), space.wrap(13)) diff --git a/pypy/module/cpyext/test/test_setobject.py b/pypy/module/cpyext/test/test_setobject.py --- a/pypy/module/cpyext/test/test_setobject.py +++ b/pypy/module/cpyext/test/test_setobject.py @@ -1,31 +1,30 @@ -import py - -from pypy.module.cpyext.pyobject import PyObject, PyObjectP, make_ref, from_ref -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase -from rpython.rtyper.lltypesystem import rffi, lltype +from pypy.module.cpyext.setobject import ( + PySet_Check, PyFrozenSet_Check, PyFrozenSet_CheckExact, + PySet_Add, PySet_Size, PySet_GET_SIZE) class TestTupleObject(BaseApiTest): - def test_setobj(self, space, api): - assert not api.PySet_Check(space.w_None) - assert not api.PyFrozenSet_Check(space.w_None) - assert api.PySet_Add(space.w_None, space.w_None) == -1 - api.PyErr_Clear() + def test_setobj(self, space): + assert not PySet_Check(space, space.w_None) + assert not PyFrozenSet_Check(space, space.w_None) + with raises_w(space, SystemError): + PySet_Add(space, space.w_None, space.w_None) w_set = space.call_function(space.w_set) - assert not api.PyFrozenSet_CheckExact(w_set) - space.call_method(w_set, 'update', space.wrap([1,2,3,4])) - assert api.PySet_Size(w_set) == 4 - assert api.PySet_GET_SIZE(w_set) == 4 - raises(TypeError, api.PySet_Size(space.newlist([]))) - api.PyErr_Clear() + assert not PyFrozenSet_CheckExact(space, w_set) + space.call_method(w_set, 'update', space.wrap([1, 2, 3, 4])) + assert PySet_Size(space, w_set) == 4 + assert PySet_GET_SIZE(space, w_set) == 4 + with raises_w(space, TypeError): + PySet_Size(space, space.newlist([])) def test_set_add_discard(self, space, api): w_set = api.PySet_New(None) assert api.PySet_Size(w_set) == 0 - w_set = api.PyFrozenSet_New(space.wrap([1,2,3,4])) + w_set = api.PyFrozenSet_New(space.wrap([1, 2, 3, 4])) assert api.PySet_Size(w_set) == 4 - w_set = api.PySet_New(space.wrap([1,2,3,4])) + w_set = api.PySet_New(space.wrap([1, 2, 3, 4])) assert api.PySet_Size(w_set) == 4 api.PySet_Add(w_set, space.wrap(6)) assert api.PySet_Size(w_set) == 5 @@ -33,14 +32,14 @@ assert api.PySet_Size(w_set) == 4 def test_set_contains(self, space, api): - w_set = api.PySet_New(space.wrap([1,2,3,4])) + w_set = api.PySet_New(space.wrap([1, 2, 3, 4])) assert api.PySet_Contains(w_set, space.wrap(1)) assert not api.PySet_Contains(w_set, space.wrap(0)) def test_set_pop_clear(self, space, api): - w_set = api.PySet_New(space.wrap([1,2,3,4])) + w_set = api.PySet_New(space.wrap([1, 2, 3, 4])) w_obj = api.PySet_Pop(w_set) - assert space.int_w(w_obj) in (1,2,3,4) + assert space.int_w(w_obj) in (1, 2, 3, 4) assert space.len_w(w_set) == 3 api.PySet_Clear(w_set) assert space.len_w(w_set) == 0 @@ -72,6 +71,5 @@ PySet_GET_SIZE(dumb_pointer); return o; - """ - ) + """) ]) diff --git a/pypy/module/cpyext/test/test_sliceobject.py b/pypy/module/cpyext/test/test_sliceobject.py --- a/pypy/module/cpyext/test/test_sliceobject.py +++ b/pypy/module/cpyext/test/test_sliceobject.py @@ -2,13 +2,14 @@ from pypy.module.cpyext.test.test_api import BaseApiTest from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase from pypy.module.cpyext.api import Py_ssize_t, Py_ssize_tP +from pypy.module.cpyext.sliceobject import PySlice_Check class TestSliceObject(BaseApiTest): - def test_slice(self, space, api): + def test_slice(self, space): w_i = space.wrap(10) w_slice = space.newslice(w_i, w_i, w_i) - assert api.PySlice_Check(w_slice) - assert not api.PySlice_Check(w_i) + assert PySlice_Check(space, w_slice) + assert not PySlice_Check(space, w_i) def test_GetIndicesEx(self, space, api): w = space.wrap diff --git a/pypy/module/cpyext/test/test_tupleobject.py b/pypy/module/cpyext/test/test_tupleobject.py --- a/pypy/module/cpyext/test/test_tupleobject.py +++ b/pypy/module/cpyext/test/test_tupleobject.py @@ -1,24 +1,25 @@ import py from pypy.module.cpyext.pyobject import PyObject, PyObjectP, make_ref, from_ref -from pypy.module.cpyext.tupleobject import PyTupleObject -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase from rpython.rtyper.lltypesystem import rffi, lltype from rpython.rlib.debug import FatalError +from pypy.module.cpyext.tupleobject import ( + PyTupleObject, PyTuple_Check, PyTuple_SetItem, PyTuple_Size) class TestTupleObject(BaseApiTest): - def test_tupleobject(self, space, api): - assert not api.PyTuple_Check(space.w_None) - assert api.PyTuple_SetItem(space.w_None, 0, space.w_None) == -1 + def test_tupleobject(self, space): + assert not PyTuple_Check(space, space.w_None) + with raises_w(space, SystemError): + PyTuple_SetItem(space, space.w_None, 0, space.w_None) atuple = space.newtuple([space.wrap(0), space.wrap(1), space.wrap('yay')]) - assert api.PyTuple_Size(atuple) == 3 - #assert api.PyTuple_GET_SIZE(atuple) == 3 --- now a C macro - raises(TypeError, api.PyTuple_Size(space.newlist([]))) - api.PyErr_Clear() + assert PyTuple_Size(space, atuple) == 3 + with raises_w(space, SystemError): + PyTuple_Size(space, space.newlist([])) def test_tuple_realize_refuses_nulls(self, space, api): py_tuple = api.PyTuple_New(1) diff --git a/pypy/module/cpyext/test/test_weakref.py b/pypy/module/cpyext/test/test_weakref.py --- a/pypy/module/cpyext/test/test_weakref.py +++ b/pypy/module/cpyext/test/test_weakref.py @@ -1,5 +1,6 @@ from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase -from pypy.module.cpyext.test.test_api import BaseApiTest +from pypy.module.cpyext.test.test_api import BaseApiTest, raises_w +from pypy.module.cpyext.weakrefobject import PyWeakref_NewRef class TestWeakReference(BaseApiTest): def test_weakref(self, space, api): @@ -10,12 +11,11 @@ assert space.is_w(api.PyWeakref_LockObject(w_ref), w_obj) w_obj = space.newtuple([]) - assert api.PyWeakref_NewRef(w_obj, space.w_None) is None - assert api.PyErr_Occurred() is space.w_TypeError - api.PyErr_Clear() + with raises_w(space, TypeError): + PyWeakref_NewRef(space, w_obj, space.w_None) def test_proxy(self, space, api): - w_obj = space.w_Warning # some weakrefable object + w_obj = space.w_Warning # some weakrefable object w_proxy = api.PyWeakref_NewProxy(w_obj, None) assert space.unwrap(space.str(w_proxy)) == "<class 'Warning'>" assert space.unwrap(space.repr(w_proxy)).startswith('<weak') diff --git a/pypy/module/test_lib_pypy/test_stackless.py b/pypy/module/test_lib_pypy/test_stackless.py --- a/pypy/module/test_lib_pypy/test_stackless.py +++ b/pypy/module/test_lib_pypy/test_stackless.py @@ -599,4 +599,23 @@ stackless.run() - + def test_kill_tasklet_waiting_for_channel(self): + # issue #2595 + c = stackless.channel() + def sender(): + c.send(1) + def receiver(): + v = c.receive() + def killer(tl): + tl.kill() + def main(): + trk = stackless.tasklet(receiver)() + stackless.schedule() + killer(trk) + stackless.schedule() + stackless.tasklet(sender)() + stackless.schedule() + stackless.tasklet(receiver)() + stackless.schedule() + stackless.tasklet(main)() + stackless.run() diff --git a/rpython/rlib/test/test_rposix.py b/rpython/rlib/test/test_rposix.py --- a/rpython/rlib/test/test_rposix.py +++ b/rpython/rlib/test/test_rposix.py @@ -753,6 +753,9 @@ @rposix_requires('posix_fadvise') def test_posix_fadvise(): + if sys.maxint <= 2**32: + py.test.skip("ll2ctypes run of posix_fadvise() on 32-bit " + "gets confused by the size of OFF_T") fname = str(udir.join('test_os_posix_fadvise')) fd = os.open(fname, os.O_CREAT | os.O_RDWR) try: @@ -769,6 +772,9 @@ @rposix_requires('posix_fallocate') def test_posix_fallocate(): + if sys.maxint <= 2**32: + py.test.skip("ll2ctypes run of posix_fallocate() on 32-bit " + "gets confused by the size of OFF_T") fname = str(udir.join('os_test.txt')) _______________________________________________ pypy-commit mailing list pypy-commit@python.org https://mail.python.org/mailman/listinfo/pypy-commit