#undef NDEBUG

#ifndef MODULE_NAME

# error "MODULE_NAME macro is not set"

#include "pythoncapi_compat.h"

#include <structmember.h> // T_SHORT, READONLY

#ifdef NDEBUG

# error "assertions must be enabled"

#define _STR(NAME) #NAME

#define STR(NAME) _STR(NAME)

#define _CONCAT(a, b) a ## b

#define CONCAT(a, b) _CONCAT(a, b)

#define MODULE_NAME_STR STR(MODULE_NAME)

#ifndef PYPY_VERSION

# define CHECK_REFCNT

#if _Py_PACK_VERSION(3, 12) <= PY_VERSION_HEX && !defined(PYPY_VERSION)

// Don't check reference count of Python 3.12 immortal objects (ex: bool

// and str types)

# define IMMORTAL_OBJS

#ifdef CHECK_REFCNT

# define ASSERT_REFCNT(expr) assert(expr)

# define ASSERT_REFCNT(expr)

static const char uninitialized[] = "uninitialized";

#define UNINITIALIZED_OBJ ((PyObject *)uninitialized)

#define UNINITIALIZED_INT 0x83ff979

static PyObject*

create_string(const char *str)

{

PyObject *obj = PyUnicode_FromString(str);

assert(obj != _Py_NULL);

return obj;

}

static PyObject *

test_object(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyObject *obj = PyList_New(0);

if (obj == _Py_NULL) {

return _Py_NULL;

}

Py_ssize_t refcnt = Py_REFCNT(obj);

// Py_NewRef()

PyObject *ref = Py_NewRef(obj);

assert(ref == obj);

assert(Py_REFCNT(obj) == (refcnt + 1));

Py_DECREF(ref);

// Py_XNewRef()

PyObject *xref = Py_XNewRef(obj);

assert(xref == obj);

assert(Py_REFCNT(obj) == (refcnt + 1));

Py_DECREF(xref);

assert(Py_XNewRef(_Py_NULL) == _Py_NULL);

// Py_SETREF()

PyObject *setref = Py_NewRef(obj);

PyObject *none = Py_None;

assert(Py_REFCNT(obj) == (refcnt + 1));

Py_SETREF(setref, none);

assert(setref == none);

assert(Py_REFCNT(obj) == refcnt);

Py_INCREF(setref);

Py_SETREF(setref, _Py_NULL);

assert(setref == _Py_NULL);

// Py_XSETREF()

PyObject *xsetref = _Py_NULL;

Py_INCREF(obj);

assert(Py_REFCNT(obj) == (refcnt + 1));

Py_XSETREF(xsetref, obj);

assert(xsetref == obj);

Py_XSETREF(xsetref, _Py_NULL);

assert(Py_REFCNT(obj) == refcnt);

assert(xsetref == _Py_NULL);

// Py_SET_REFCNT

Py_SET_REFCNT(obj, Py_REFCNT(obj));

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 < _Py_PACK_VERSION(3, 10)

// Py_SET_TYPE

Py_SET_TYPE(obj, Py_TYPE(obj));

// Py_SET_SIZE

Py_SET_SIZE(_PyVarObject_CAST(obj), Py_SIZE(obj));

// Py_IS_TYPE()

int is_type = Py_IS_TYPE(obj, Py_TYPE(obj));

assert(is_type);

assert(Py_REFCNT(obj) == refcnt);

Py_DECREF(obj);

Py_RETURN_NONE;

}

static PyObject *

test_py_is(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyObject *o_none = Py_None;

PyObject *o_true = Py_True;

PyObject *o_false = Py_False;

PyObject *obj = PyList_New(0);

if (obj == _Py_NULL) {

return _Py_NULL;

}

/* test Py_Is() */

assert(Py_Is(obj, obj));

assert(!Py_Is(obj, o_none));

/* test Py_IsNone() */

assert(Py_IsNone(o_none));

assert(!Py_IsNone(obj));

/* test Py_IsTrue() */

assert(Py_IsTrue(o_true));

assert(!Py_IsTrue(o_false));

assert(!Py_IsTrue(obj));

/* testPy_IsFalse() */

assert(Py_IsFalse(o_false));

assert(!Py_IsFalse(o_true));

assert(!Py_IsFalse(obj));

Py_DECREF(obj);

Py_RETURN_NONE;

}

#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)

static void

test_frame_getvar(PyFrameObject *frame)

{

// Make the assumption that test_frame_getvar() is only called by

// _run_tests() of test_pythoncapi_compat.py and so that the "name"

// variable exists.

// test PyFrame_GetVar() and PyFrame_GetVarString()

PyObject *attr = PyUnicode_FromString("name");

assert(attr != _Py_NULL);

PyObject *name1 = PyFrame_GetVar(frame, attr);

Py_DECREF(attr);

assert(name1 != _Py_NULL);

Py_DECREF(name1);

PyObject *name2 = PyFrame_GetVarString(frame, "name");

assert(name2 != _Py_NULL);

Py_DECREF(name2);

// test PyFrame_GetVar() and PyFrame_GetVarString() NameError

PyObject *attr3 = PyUnicode_FromString("dontexist");

assert(attr3 != _Py_NULL);

PyObject *name3 = PyFrame_GetVar(frame, attr3);

Py_DECREF(attr3);

assert(name3 == _Py_NULL);

assert(PyErr_ExceptionMatches(PyExc_NameError));

PyErr_Clear();

PyObject *name4 = PyFrame_GetVarString(frame, "dontexist");

assert(name4 == _Py_NULL);

assert(PyErr_ExceptionMatches(PyExc_NameError));

PyErr_Clear();

}

#if ((!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= _Py_PACK_VERSION(3, 9)) \

&& (!defined(PYPY_VERSION) || PY_VERSION_HEX >= _Py_PACK_VERSION(3, 11)))

static PyObject *

test_frame(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyThreadState *tstate = PyThreadState_Get();

// test PyThreadState_GetFrame()

PyFrameObject *frame = PyThreadState_GetFrame(tstate);

if (frame == _Py_NULL) {

PyErr_SetString(PyExc_AssertionError, "PyThreadState_GetFrame failed");

return _Py_NULL;

}

// Test issue: the current thread has no code on PyPy

#ifndef PYPY_VERSION

// test PyFrame_GetCode()

PyCodeObject *code = PyFrame_GetCode(frame);

assert(code != _Py_NULL);

#ifndef Py_LIMITED_API

assert(PyCode_Check(code));

Py_DECREF(code);

#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)

// PyFrame_GetBack()

PyFrameObject* back = PyFrame_GetBack(frame);

if (back != _Py_NULL) {

assert(PyFrame_Check(back));

Py_DECREF(back);

}

// test PyFrame_GetLocals()

PyObject *locals = PyFrame_GetLocals(frame);

assert(locals != _Py_NULL);

// Python 3.13 creates a local proxy

#if PY_VERSION_HEX < _Py_PACK_VERSION(3, 13)

assert(PyDict_Check(locals));

// test PyFrame_GetGlobals()

PyObject *globals = PyFrame_GetGlobals(frame);

assert(globals != _Py_NULL);

assert(PyDict_Check(globals));

// test PyFrame_GetBuiltins()

PyObject *builtins = PyFrame_GetBuiltins(frame);

assert(builtins != _Py_NULL);

assert(PyDict_Check(builtins));

assert(locals != globals);

assert(globals != builtins);

assert(builtins != locals);

Py_DECREF(locals);

Py_DECREF(globals);

Py_DECREF(builtins);

// test PyFrame_GetLasti()

int lasti = PyFrame_GetLasti(frame);

assert(lasti >= 0);

#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)

// test PyFrame_GetVar() and PyFrame_GetVarString()

test_frame_getvar(frame);

// done

Py_DECREF(frame);

Py_RETURN_NONE;

}

#endif // !PYPY_VERSION

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= _Py_PACK_VERSION(3, 9)

static PyObject *

test_thread_state(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyThreadState *tstate = PyThreadState_Get();

// test PyThreadState_GetInterpreter()

PyInterpreterState *interp = PyThreadState_GetInterpreter(tstate);

assert(interp != _Py_NULL);

#ifndef PYPY_VERSION

// test PyThreadState_GetFrame()

PyFrameObject *frame = PyThreadState_GetFrame(tstate);

if (frame != _Py_NULL) {

#ifndef Py_LIMITED_API

assert(PyFrame_Check(frame));

}

Py_XDECREF(_PyObject_CAST(frame));

#if _Py_PACK_VERSION(3, 7) <= PY_VERSION_HEX && !defined(PYPY_VERSION)

uint64_t id = PyThreadState_GetID(tstate);

assert(id > 0);

#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)

// test PyThreadState_EnterTracing() and PyThreadState_LeaveTracing()

PyThreadState_EnterTracing(tstate);

PyThreadState_LeaveTracing(tstate);

#if PY_VERSION_HEX >= _Py_PACK_VERSION(3, 5) && !defined(Py_LIMITED_API)

// PyThreadState_GetUnchecked()

assert(PyThreadState_GetUnchecked() == tstate);

Py_RETURN_NONE;

}

static PyObject *

test_interpreter(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

// On Windows,PyInterpreterState_Get() is not available in stable ABI 3.9,

// only in stable ABI 3.10. Don't test it on limited C API 3.9 on Unix to

// make the test simpler.

#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= _Py_PACK_VERSION(3, 10)

// test PyInterpreterState_Get()

PyInterpreterState *interp = PyInterpreterState_Get();

assert(interp != _Py_NULL);

// test PyThreadState_GetInterpreter()

PyThreadState *tstate = PyThreadState_Get();

PyInterpreterState *interp2 = PyThreadState_GetInterpreter(tstate);

assert(interp == interp2);

#if (_Py_PACK_VERSION(3, 3) <= PY_VERSION_HEX \

&& (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x7030000) \

&& (!defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= _Py_PACK_VERSION(3, 13)))

// test Py_IsFinalizing()

assert(Py_IsFinalizing() == 0);

Py_RETURN_NONE;

}

static PyObject *

test_calls(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyObject *func = _Py_CAST(PyObject*, &PyUnicode_Type);

// test PyObject_CallNoArgs(): str() returns ''

PyObject *res = PyObject_CallNoArgs(func);

if (res == _Py_NULL) {

return _Py_NULL;

}

assert(PyUnicode_Check(res));

Py_DECREF(res);

// test PyObject_CallOneArg(): str(1) returns '1'

PyObject *arg = PyLong_FromLong(1);

if (arg == _Py_NULL) {

return _Py_NULL;

}

res = PyObject_CallOneArg(func, arg);

Py_DECREF(arg);

if (res == _Py_NULL) {

return _Py_NULL;

}

assert(PyUnicode_Check(res));

Py_DECREF(res);

Py_RETURN_NONE;

}

#if (!defined(Py_LIMITED_API) || PY_VERSION_HEX >= _Py_PACK_VERSION(3, 10)) \

&& !defined(PYPY_VERSION)

static PyObject *

test_gc(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyObject *tuple = Py_BuildValue("(O)", Py_None);

if (tuple == NULL) {

return NULL;

}

// test PyObject_GC_IsTracked()

int tracked = PyObject_GC_IsTracked(tuple);

assert(tracked);

// test PyObject_GC_IsFinalized()

int finalized = PyObject_GC_IsFinalized(tuple);

assert(!finalized);

Py_DECREF(tuple);

Py_RETURN_NONE;

}

static int

check_module_attr(PyObject *module, const char *name, PyObject *expected)

{

PyObject *attr = PyObject_GetAttrString(module, name);

if (attr == _Py_NULL) {

return -1;

}

assert(attr == expected);

Py_DECREF(attr);

if (PyObject_DelAttrString(module, name) < 0) {

return -1;

}

return 0;

}

static int

test_module_add_type(PyObject *module)

{

PyTypeObject *type = &PyUnicode_Type;

const char *type_name = "str";

#ifdef CHECK_REFCNT

Py_ssize_t refcnt = Py_REFCNT(_PyObject_CAST(type));

if (PyModule_AddType(module, type) < 0) {

return -1;

}

#ifndef IMMORTAL_OBJS

ASSERT_REFCNT(Py_REFCNT(_PyObject_CAST(type)) == refcnt + 1);

if (check_module_attr(module, type_name, _Py_CAST(PyObject*, type)) < 0) {

return -1;

}

ASSERT_REFCNT(Py_REFCNT(_PyObject_CAST(type)) == refcnt);

return 0;

}

static int

test_module_addobjectref(PyObject *module)

{

const char *name = "test_module_addobjectref";

PyObject *obj = PyUnicode_FromString(name);

assert(obj != _Py_NULL);

#ifdef CHECK_REFCNT

Py_ssize_t refcnt = Py_REFCNT(obj);

if (PyModule_AddObjectRef(module, name, obj) < 0) {

ASSERT_REFCNT(Py_REFCNT(obj) == refcnt);

Py_DECREF(obj);

return -1;

}

ASSERT_REFCNT(Py_REFCNT(obj) == refcnt + 1);

if (check_module_attr(module, name, obj) < 0) {

Py_DECREF(obj);

return -1;

}

ASSERT_REFCNT(Py_REFCNT(obj) == refcnt);

// PyModule_AddObjectRef() with value=NULL must not crash

assert(!PyErr_Occurred());

int res = PyModule_AddObjectRef(module, name, _Py_NULL);

assert(res < 0);

assert(PyErr_ExceptionMatches(PyExc_SystemError));

PyErr_Clear();

Py_DECREF(obj);

return 0;

}

static int

test_module_add(PyObject *module)

{

const char *name = "test_module_add";

PyObject *obj = PyUnicode_FromString(name);

assert(obj != _Py_NULL);

#ifdef CHECK_REFCNT

Py_ssize_t refcnt = Py_REFCNT(obj);

if (PyModule_Add(module, name, Py_NewRef(obj)) < 0) {

ASSERT_REFCNT(Py_REFCNT(obj) == refcnt);

Py_DECREF(obj);

return -1;

}

ASSERT_REFCNT(Py_REFCNT(obj) == refcnt + 1);

if (check_module_attr(module, name, obj) < 0) {

Py_DECREF(obj);

return -1;

}

ASSERT_REFCNT(Py_REFCNT(obj) == refcnt);

// PyModule_Add() with value=NULL must not crash

assert(!PyErr_Occurred());

int res = PyModule_Add(module, name, _Py_NULL);

assert(res < 0);

assert(PyErr_ExceptionMatches(PyExc_SystemError));

PyErr_Clear();

Py_DECREF(obj);

return 0;

}

static PyObject *

test_module(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyObject *module = PyImport_ImportModule("sys");

if (module == _Py_NULL) {

return _Py_NULL;

}

assert(PyModule_Check(module));

if (test_module_add_type(module) < 0) {

goto error;

}

if (test_module_addobjectref(module) < 0) {

goto error;

}

if (test_module_add(module) < 0) {

goto error;

}

Py_DECREF(module);

Py_RETURN_NONE;

error:

Py_DECREF(module);

return _Py_NULL;

}

#if !defined(PYPY_VERSION) && !defined(Py_LIMITED_API)

static PyObject *

test_float_pack(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

const int big_endian = 0;

const int little_endian = 1;

char data[8];

const double d = 1.5;

#if PY_VERSION_HEX >= _Py_PACK_VERSION(3, 6)

# define HAVE_FLOAT_PACK2

// Test Pack (big endian)

#ifdef HAVE_FLOAT_PACK2

assert(PyFloat_Pack2(d, data, big_endian) == 0);

assert(memcmp(data, ">\x00", 2) == 0);

assert(PyFloat_Pack4(d, data, big_endian) == 0);

assert(memcmp(data, "?\xc0\x00\x00", 2) == 0);

assert(PyFloat_Pack8(d, data, big_endian) == 0);

assert(memcmp(data, "?\xf8\x00\x00\x00\x00\x00\x00", 2) == 0);

// Test Pack (little endian)

#ifdef HAVE_FLOAT_PACK2

assert(PyFloat_Pack2(d, data, little_endian) == 0);

assert(memcmp(data, "\x00>", 2) == 0);

assert(PyFloat_Pack4(d, data, little_endian) == 0);

assert(memcmp(data, "\x00\x00\xc0?", 2) == 0);

assert(PyFloat_Pack8(d, data, little_endian) == 0);

assert(memcmp(data, "\x00\x00\x00\x00\x00\x00\xf8?", 2) == 0);

// Test Unpack (big endian)

#ifdef HAVE_FLOAT_PACK2

assert(PyFloat_Unpack2(">\x00", big_endian) == d);

assert(PyFloat_Unpack4("?\xc0\x00\x00", big_endian) == d);

assert(PyFloat_Unpack8("?\xf8\x00\x00\x00\x00\x00\x00", big_endian) == d);

// Test Unpack (little endian)

#ifdef HAVE_FLOAT_PACK2

assert(PyFloat_Unpack2("\x00>", little_endian) == d);

assert(PyFloat_Unpack4("\x00\x00\xc0?", little_endian) == d);

assert(PyFloat_Unpack8("\x00\x00\x00\x00\x00\x00\xf8?", little_endian) == d);

Py_RETURN_NONE;

}

#if ((!defined(PYPY_VERSION) || PY_VERSION_HEX >= _Py_PACK_VERSION(3, 11)) \

&& !defined(Py_LIMITED_API))

static PyObject *

test_code(PyObject *Py_UNUSED(module), PyObject* Py_UNUSED(ignored))

{

PyObject *func = PyImport_ImportModuleAttrString("colorsys", "rgb_to_yiq");

if (func == NULL) {

return NULL;

}

PyObject *code_obj = PyObject_GetAttrString(func, "__code__");

Py_DECREF(func);

assert(PyCode_Check(code_obj));

PyCodeObject *code = (PyCodeObject*)code_obj;

// Test PyCode_GetCode()

{

PyObject *co_code = PyCode_GetCode(code);

assert(co_code != _Py_NULL);

assert(PyBytes_Check(co_code));

Py_DECREF(co_code);

}

// Test PyCode_GetVarnames()

{

PyObject *co_varnames = PyCode_GetVarnames(code);

assert(co_varnames != _Py_NULL);

assert(PyTuple_CheckExact(co_varnames));

assert(PyTuple_GET_SIZE(co_varnames) != 0);

Py_DECREF(co_varnames);

}

// Test PyCode_GetCellvars()

{

PyObject *co_cellvars = PyCode_GetCellvars(code);

assert(co_cellvars != _Py_NULL);

assert(PyTuple_CheckExact(co_cellvars));

assert(PyTuple_GET_SIZE(co_cellvars) == 0);

Py_DECREF(co_cellvars);

}

// Test PyCode_GetFreevars()

{

PyObject *co_freevars = PyCode_GetFreevars(code);

assert(co_freevars != _Py_NULL);

assert(PyTuple_CheckExact(co_freevars));

assert(PyTuple_GET_SIZE(co_freevars) == 0);

Py_DECREF(co_freevars);

}

Py_DECREF(code);

Py_RETURN_NONE;

}

#ifdef __cplusplus

class StrongRef

{

public:

StrongRef(PyObject *obj) : m_obj(obj) {

Py_INCREF(this->m_obj);

}

~StrongRef() {

Py_DECREF(this->m_obj);

}

// Cast to PyObject*: get a borrowed reference

inline operator PyObject*() const { return this->m_obj; }

private:

PyObject *m_obj; // Strong reference

};

static PyObject *

test_api_casts(PyObject *Py_UNUSED(module), PyObject *Py_UNUSED(args))

{

PyObject *obj = Py_BuildValue("(ii)", 1, 2);

if (obj == _Py_NULL) {

return _Py_NULL;

}

Py_ssize_t refcnt = Py_REFCNT(obj);

assert(refcnt >= 1);

#ifndef Py_LIMITED_API

// gh-92138: For backward compatibility, functions of Python C API accepts

// "const PyObject*". Check that using it does not emit C++ compiler

// warnings.

const PyObject *const_obj = obj;

Py_INCREF(const_obj);

Py_DECREF(const_obj);

PyTypeObject *type = Py_TYPE(const_obj);

assert(Py_REFCNT(const_obj) == refcnt);

assert(type == &PyTuple_Type);

assert(PyTuple_GET_SIZE(const_obj) == 2);

PyObject *one = PyTuple_GET_ITEM(const_obj, 0);

assert(PyLong_AsLong(one) == 1);

#ifdef __cplusplus

// gh-92898: StrongRef doesn't inherit from PyObject but has an operator to

// cast to PyObject*.

StrongRef strong_ref(obj);

assert(Py_TYPE(strong_ref) == &PyTuple_Type);

assert(Py_REFCNT(strong_ref) == (refcnt + 1));

Py_INCREF(strong_ref);

Py_DECREF(strong_ref);

// gh-93442: Pass 0 as NULL for PyObject*

Py_XINCREF(0);

Py_XDECREF(0);

#if _cplusplus >= 201103

// Test nullptr passed as PyObject*

Py_XINCREF(nullptr);

Py_XDECREF(nullptr);

Py_DECREF(obj);

Py_RETURN_NONE;

}

static PyObject *

test_import(PyObject *Py_UNUSED(module), PyObject *Py_UNUSED(args))

{

PyObject *mod = PyImport_ImportModule("sys");

if (mod == _Py_NULL) {

return _Py_NULL;

}

Py_ssize_t refcnt = Py_REFCNT(mod);

// test PyImport_AddModuleRef()

PyObject *mod2 = PyImport_AddModuleRef("sys");

if (mod2 == _Py_NULL) {

return _Py_NULL;

}

assert(PyModule_Check(mod2));

assert(Py_REFCNT(mod) == (refcnt + 1));

Py_DECREF(mod2);

Py_DECREF(mod);

// Test PyImport_ImportModuleAttr()

PyObject *mod_name = PyUnicode_FromString("sys");

assert(mod_name != NULL);

PyObject *attr_name = PyUnicode_FromString("platform");

assert(attr_name != NULL);

PyObject *attr = PyImport_ImportModuleAttr(mod_name, attr_name);

Py_DECREF(mod_name);

Py_DECREF(attr_name);

if (attr == NULL) {

return NULL;

}

assert(PyUnicode_Check(attr));

Py_DECREF(attr);

// Test PyImport_ImportModuleAttrString()

attr = PyImport_ImportModuleAttrString("sys", "platform");

if (attr == NULL) {

return NULL;

}

assert(PyUnicode_Check(attr));

Py_DECREF(attr);

Py_RETURN_NONE;

}

static void

gc_collect(void)

{

#if defined(PYPY_VERSION) && PY_VERSION_HEX < _Py_PACK_VERSION(3, 11)

PyObject *mod = PyImport_ImportModule("gc");

assert(mod != _Py_NULL);

PyObject *res = PyObject_CallMethod(mod, "collect", _Py_NULL);

Py_DECREF(mod);

assert(res != _Py_NULL);

Py_DECREF(res);

PyGC_Collect();

}

static PyObject *

func_varargs(PyObject *Py_UNUSED(module), PyObject *args, PyObject *kwargs)

{

if (kwargs != _Py_NULL) {

return PyTuple_Pack(2, args, kwargs);

}

else {

return PyTuple_Pack(1, args);

}

}

static PyObject *

test_weakref(PyObject *Py_UNUSED(module), PyObject *Py_UNUSED(args))

{

// Create a new heap type, create an instance of this type, and delete the

// type. This object supports weak references.

PyObject *new_type = PyObject_CallFunction((PyObject*)&PyType_Type,

"s(){}", "TypeName");

if (new_type == _Py_NULL) {

return _Py_NULL;

}

PyObject *obj = PyObject_CallNoArgs(new_type);

Py_DECREF(new_type);

if (obj == _Py_NULL) {

return _Py_NULL;

}

Py_ssize_t refcnt = Py_REFCNT(obj);

// create a weak reference

PyObject *weakref = PyWeakref_NewRef(obj, _Py_NULL);

if (weakref == _Py_NULL) {

return _Py_NULL;

}

// test PyWeakref_GetRef(), reference is alive

PyObject *ref = UNINITIALIZED_OBJ;

assert(PyWeakref_GetRef(weakref, &ref) == 1);

assert(ref == obj);

assert(Py_REFCNT(obj) == (refcnt + 1));

Py_DECREF(ref);

// delete the referenced object: clear the weakref

Py_DECREF(obj);

gc_collect();

// test PyWeakref_GetRef(), reference is dead

ref = Py_True;

assert(PyWeakref_GetRef(weakref, &ref) == 0);

assert(ref == _Py_NULL);

// test PyWeakref_GetRef(), invalid type

PyObject *invalid_weakref = Py_None;

assert(!PyErr_Occurred());

ref = Py_True;

assert(PyWeakref_GetRef(invalid_weakref, &ref) == -1);

assert(PyErr_ExceptionMatches(PyExc_TypeError));

assert(ref == _Py_NULL);

PyErr_Clear();

#ifndef PYPY_VERSION

// test PyWeakref_GetRef(NULL)

ref = Py_True;

assert(PyWeakref_GetRef(_Py_NULL, &ref) == -1);

assert(PyErr_ExceptionMatches(PyExc_SystemError));

assert(ref == _Py_NULL);

PyErr_Clear();

Py_DECREF(weakref);

Py_RETURN_NONE;

}

static void

check_int(PyObject *obj, int value)

{

assert(PyLong_Check(obj));

assert(PyLong_AsLong(obj) == value);

}

static void

test_vectorcall_noargs(PyObject *func_varargs)

{

PyObject *res = PyObject_Vectorcall(func_varargs, _Py_NULL, 0, _Py_NULL);

assert(res != _Py_NULL);

assert(PyTuple_Check(res));

assert(PyTuple_Size(res) == 1);

PyObject *posargs = PyTuple_GetItem(res, 0);

assert(PyTuple_Check(posargs));

assert(PyTuple_Size(posargs) == 0);

Py_DECREF(res);

}

static void

test_vectorcall_args(PyObject *func_varargs)

{

PyObject* args[2];

args[0] = PyLong_FromLong(1);

args[1] = PyLong_FromLong(2);

assert(args[0] != _Py_NULL && args[1] != _Py_NULL);

PyObject *res = PyObject_Vectorcall(func_varargs, args, 2, _Py_NULL);

Py_DECREF(args[0]);

Py_DECREF(args[1]);

assert(res != _Py_NULL);

assert(PyTuple_Check(res));

assert(PyTuple_Size(res) == 1);

PyObject *posargs = PyTuple_GetItem(res, 0);

assert(PyTuple_Check(posargs));

assert(PyTuple_Size(posargs) == 2);

check_int(PyTuple_GetItem(posargs, 0), 1);

check_int(PyTuple_GetItem(posargs, 1), 2);

Py_DECREF(res);

}

static void

test_vectorcall_args_offset(PyObject *func_varargs)

{

// args contains 3 values, but only pass 2 last values

PyObject* args[3];

args[0] = PyLong_FromLong(1);

args[1] = PyLong_FromLong(2);

args[2] = PyLong_FromLong(3);

assert(args[0] != _Py_NULL && args[1] != _Py_NULL && args[2] != _Py_NULL);

size_t nargs = 2 | PY_VECTORCALL_ARGUMENTS_OFFSET;

PyObject *res = PyObject_Vectorcall(func_varargs, &args[1], nargs, _Py_NULL);

Py_DECREF(args[0]);

Py_DECREF(args[1]);

Py_DECREF(args[2]);

assert(res != _Py_NULL);

assert(PyTuple_Check(res));

assert(PyTuple_Size(res) == 1);

PyObject *posargs = PyTuple_GetItem(res, 0);

assert(PyTuple_Check(posargs));

assert(PyTuple_Size(posargs) == 2);

check_int(PyTuple_GetItem(posargs, 0), 2);

check_int(PyTuple_GetItem(posargs, 1), 3);

Py_DECREF(res);

}

static void

test_vectorcall_args_kwnames(PyObject *func_varargs)

{

PyObject* args[5];

args[0] = PyLong_FromLong(1);

args[1] = PyLong_FromLong(2);

args[2] = PyLong_FromLong(3);

args[3] = PyLong_FromLong(4);

args[4] = PyLong_FromLong(5);

assert(args[0] != _Py_NULL && args[1] != _Py_NULL && args[2] != _Py_NULL

&& args[3] != _Py_NULL && args[4] != _Py_NULL);

PyObject *key1 = PyUnicode_FromString("key1");

PyObject *key2 = PyUnicode_FromString("key2");

assert(key1 != _Py_NULL);

assert(key2 != _Py_NULL);

PyObject *kwnames = PyTuple_Pack(2, key1, key2);

assert(kwnames != _Py_NULL);

size_t nargs = (size_t)(Py_ARRAY_LENGTH(args) - (size_t)PyTuple_Size(kwnames));

PyObject *res = PyObject_Vectorcall(func_varargs, args, nargs, kwnames);

for (size_t i = 0; i < Py_ARRAY_LENGTH(args); i++) {

Py_DECREF(args[i]);

}

Py_DECREF(kwnames);

assert(res != _Py_NULL);

assert(PyTuple_Check(res));

assert(PyTuple_Size(res) == 2);

PyObject *posargs = PyTuple_GetItem(res, 0);

PyObject *kwargs = PyTuple_GetItem(res, 1);

assert(PyTuple_Check(posargs));

assert(PyTuple_Size(posargs) == 3);

check_int(PyTuple_GetItem(posargs, 0), 1);

check_int(PyTuple_GetItem(posargs, 1), 2);

check_int(PyTuple_GetItem(posargs, 2), 3);

assert(PyDict_Check(kwargs));

assert(PyDict_Size(kwargs) == 2);

Py_ssize_t pos = 0;

PyObject *key, *value;

while (PyDict_Next(kwargs, &pos, &key, &value)) {

assert(PyUnicode_Check(key));

if (PyObject_RichCompareBool(key, key1, Py_EQ)) {

check_int(value, 4);

}

else {

assert(PyObject_RichCompareBool(key, key2, Py_EQ));

check_int(value, 5);

}

}

Py_DECREF(res);

Py_DECREF(key1);