/Modules/testcapi_long.h

  1/* Poor-man's template.  Macros used:
  2   TESTNAME	name of the test (like test_long_api_inner)
  3   TYPENAME	the signed type (like long)
  4   F_S_TO_PY	convert signed to pylong; TYPENAME -> PyObject*
  5   F_PY_TO_S	convert pylong to signed; PyObject* -> TYPENAME
  6   F_U_TO_PY	convert unsigned to pylong; unsigned TYPENAME -> PyObject*
  7   F_PY_TO_U    convert pylong to unsigned; PyObject* -> unsigned TYPENAME
  8*/
  9
 10static PyObject *
 11TESTNAME(PyObject *error(const char*))
 12{
 13	const int NBITS = sizeof(TYPENAME) * 8;
 14	unsigned TYPENAME base;
 15	PyObject *pyresult;
 16	int i;
 17
 18	/* Note:  This test lets PyObjects leak if an error is raised.  Since
 19	   an error should never be raised, leaks are impossible <wink>. */
 20
 21	/* Test native -> PyLong -> native roundtrip identity.
 22	 * Generate all powers of 2, and test them and their negations,
 23	 * plus the numbers +-1 off from them.
 24	 */
 25	base = 1;
 26	for (i = 0;
 27	     i < NBITS + 1;  /* on last, base overflows to 0 */
 28	     ++i, base <<= 1)
 29	{
 30		int j;
 31		for (j = 0; j < 6; ++j) {
 32			TYPENAME in, out;
 33			unsigned TYPENAME uin, uout;
 34
 35			/* For 0, 1, 2 use base; for 3, 4, 5 use -base */
 36			uin = j < 3 ? base
 37				    : (unsigned TYPENAME)(-(TYPENAME)base);
 38
 39			/* For 0 & 3, subtract 1.
 40			 * For 1 & 4, leave alone.
 41			 * For 2 & 5, add 1.
 42			 */
 43			uin += (unsigned TYPENAME)(TYPENAME)(j % 3 - 1);
 44
 45			pyresult = F_U_TO_PY(uin);
 46			if (pyresult == NULL)
 47				return error(
 48				 "unsigned unexpected null result");
 49
 50			uout = F_PY_TO_U(pyresult);
 51			if (uout == (unsigned TYPENAME)-1 && PyErr_Occurred())
 52				return error(
 53					"unsigned unexpected -1 result");
 54			if (uout != uin)
 55				return error(
 56					"unsigned output != input");
 57			UNBIND(pyresult);
 58
 59			in = (TYPENAME)uin;
 60			pyresult = F_S_TO_PY(in);
 61			if (pyresult == NULL)
 62				return error(
 63					"signed unexpected null result");
 64
 65			out = F_PY_TO_S(pyresult);
 66			if (out == (TYPENAME)-1 && PyErr_Occurred())
 67				return error(
 68					"signed unexpected -1 result");
 69			if (out != in)
 70				return error(
 71					"signed output != input");
 72			UNBIND(pyresult);
 73		}
 74	}
 75
 76	/* Overflow tests.  The loop above ensured that all limit cases that
 77	 * should not overflow don't overflow, so all we need to do here is
 78	 * provoke one-over-the-limit cases (not exhaustive, but sharp).
 79	 */
 80	{
 81		PyObject *one, *x, *y;
 82		TYPENAME out;
 83		unsigned TYPENAME uout;
 84
 85		one = PyLong_FromLong(1);
 86		if (one == NULL)
 87			return error(
 88				"unexpected NULL from PyLong_FromLong");
 89
 90		/* Unsigned complains about -1? */
 91		x = PyNumber_Negative(one);
 92		if (x == NULL)
 93			return error(
 94				"unexpected NULL from PyNumber_Negative");
 95
 96		uout = F_PY_TO_U(x);
 97		if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
 98			return error(
 99				"PyLong_AsUnsignedXXX(-1) didn't complain");
100		PyErr_Clear();
101		UNBIND(x);
102
103		/* Unsigned complains about 2**NBITS? */
104		y = PyLong_FromLong((long)NBITS);
105		if (y == NULL)
106			return error(
107				"unexpected NULL from PyLong_FromLong");
108
109		x = PyNumber_Lshift(one, y); /* 1L << NBITS, == 2**NBITS */
110		UNBIND(y);
111		if (x == NULL)
112			return error(
113				"unexpected NULL from PyNumber_Lshift");
114
115  		uout = F_PY_TO_U(x);
116		if (uout != (unsigned TYPENAME)-1 || !PyErr_Occurred())
117			return error(
118				"PyLong_AsUnsignedXXX(2**NBITS) didn't "
119				"complain");
120		PyErr_Clear();
121
122		/* Signed complains about 2**(NBITS-1)?
123		   x still has 2**NBITS. */
124		y = PyNumber_Rshift(x, one); /* 2**(NBITS-1) */
125		UNBIND(x);
126		if (y == NULL)
127			return error(
128				"unexpected NULL from PyNumber_Rshift");
129
130		out = F_PY_TO_S(y);
131		if (out != (TYPENAME)-1 || !PyErr_Occurred())
132			return error(
133				"PyLong_AsXXX(2**(NBITS-1)) didn't "
134				"complain");
135		PyErr_Clear();
136
137		/* Signed complains about -2**(NBITS-1)-1?;
138		   y still has 2**(NBITS-1). */
139		x = PyNumber_Negative(y);  /* -(2**(NBITS-1)) */
140		UNBIND(y);
141		if (x == NULL)
142			return error(
143				"unexpected NULL from PyNumber_Negative");
144
145		y = PyNumber_Subtract(x, one); /* -(2**(NBITS-1))-1 */
146		UNBIND(x);
147		if (y == NULL)
148			return error(
149				"unexpected NULL from PyNumber_Subtract");
150
151		out = F_PY_TO_S(y);
152		if (out != (TYPENAME)-1 || !PyErr_Occurred())
153			return error(
154				"PyLong_AsXXX(-2**(NBITS-1)-1) didn't "
155				"complain");
156		PyErr_Clear();
157		UNBIND(y);
158
159		Py_XDECREF(x);
160		Py_XDECREF(y);
161		Py_DECREF(one);
162	}
163
164	Py_INCREF(Py_None);
165	return Py_None;
166}