From 3ecb6ab993a62f892d88def7adb5fe2954695ded Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Thu, 28 Jan 2016 19:56:04 +0200 Subject: [PATCH] Issue #26198: Added tests for string-related format units of PyArg_Parse*() functions: "s", "s*", "s#", "t#", "z", "z*", "z#", "w", "w*", "w#", "u", "u#", "es", "et", "es#", "et#" and "c". --- Lib/test/test_getargs2.py | 286 +++++++++++++++++++++++++++++++++++- Modules/_testcapimodule.c | 297 +++++++++++++++++++++++++++++++++++++- 2 files changed, 579 insertions(+), 4 deletions(-) diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py index aba304a4c8..e42f5ffd93 100644 --- a/Lib/test/test_getargs2.py +++ b/Lib/test/test_getargs2.py @@ -331,9 +331,293 @@ class Keywords_TestCase(unittest.TestCase): else: self.fail('TypeError should have been raised') + +class Bytes_TestCase(unittest.TestCase): + def test_c(self): + from _testcapi import getargs_c + self.assertRaises(TypeError, getargs_c, 'abc') # len > 1 + self.assertEqual(getargs_c('a'), 97) + if test_support.have_unicode: + self.assertRaises(TypeError, getargs_c, u's') + self.assertRaises(TypeError, getargs_c, bytearray('a')) + self.assertRaises(TypeError, getargs_c, memoryview('a')) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_c, buffer('a')) + self.assertRaises(TypeError, getargs_c, 97) + self.assertRaises(TypeError, getargs_c, None) + + def test_w(self): + from _testcapi import getargs_w + self.assertRaises(TypeError, getargs_w, 'abc', 3) + self.assertRaises(TypeError, getargs_w, u'abc', 3) + self.assertRaises(TypeError, getargs_w, bytearray('bytes'), 3) + self.assertRaises(TypeError, getargs_w, memoryview('bytes'), 3) + self.assertRaises(TypeError, getargs_w, + memoryview(bytearray('bytes')), 3) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_w, buffer('bytes'), 3) + self.assertRaises(TypeError, getargs_w, + buffer(bytearray('bytes')), 3) + self.assertRaises(TypeError, getargs_w, None, 0) + + def test_w_hash(self): + from _testcapi import getargs_w_hash + self.assertRaises(TypeError, getargs_w_hash, 'abc') + self.assertRaises(TypeError, getargs_w_hash, u'abc') + self.assertRaises(TypeError, getargs_w_hash, bytearray('bytes')) + self.assertRaises(TypeError, getargs_w_hash, memoryview('bytes')) + self.assertRaises(TypeError, getargs_w_hash, + memoryview(bytearray('bytes'))) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_w_hash, buffer('bytes')) + self.assertRaises(TypeError, getargs_w_hash, + buffer(bytearray('bytes'))) + self.assertRaises(TypeError, getargs_w_hash, None) + + def test_w_star(self): + # getargs_w_star() modifies first and last byte + from _testcapi import getargs_w_star + self.assertRaises(TypeError, getargs_w_star, 'abc') + self.assertRaises(TypeError, getargs_w_star, u'abc') + self.assertRaises(TypeError, getargs_w_star, memoryview('bytes')) + buf = bytearray('bytearray') + self.assertEqual(getargs_w_star(buf), '[ytearra]') + self.assertEqual(buf, bytearray('[ytearra]')) + buf = bytearray(b'memoryview') + self.assertEqual(getargs_w_star(memoryview(buf)), '[emoryvie]') + self.assertEqual(buf, bytearray('[emoryvie]')) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_w_star, buffer('buffer')) + self.assertRaises(TypeError, getargs_w_star, + buffer(bytearray('buffer'))) + self.assertRaises(TypeError, getargs_w_star, None) + + +class String_TestCase(unittest.TestCase): + def test_s(self): + from _testcapi import getargs_s + self.assertEqual(getargs_s('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_s(u'abc'), 'abc') + self.assertRaises(TypeError, getargs_s, 'nul:\0') + self.assertRaises(TypeError, getargs_s, u'nul:\0') + self.assertRaises(TypeError, getargs_s, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_s, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_s, buffer('buffer')) + self.assertRaises(TypeError, getargs_s, None) + + def test_s_star(self): + from _testcapi import getargs_s_star + self.assertEqual(getargs_s_star('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_s_star(u'abc'), 'abc') + self.assertEqual(getargs_s_star('nul:\0'), 'nul:\0') + self.assertEqual(getargs_s_star(u'nul:\0'), 'nul:\0') + self.assertEqual(getargs_s_star(bytearray('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_s_star(memoryview('abc\xe9')), 'abc\xe9') + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_s_star(buffer('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_s_star(buffer(u'abc\xe9')), + str(buffer(u'abc\xe9'))) + self.assertRaises(TypeError, getargs_s_star, None) + + def test_s_hash(self): + from _testcapi import getargs_s_hash + self.assertEqual(getargs_s_hash('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_s_hash(u'abc'), 'abc') + self.assertEqual(getargs_s_hash('nul:\0'), 'nul:\0') + self.assertEqual(getargs_s_hash(u'nul:\0'), 'nul:\0') + self.assertRaises(TypeError, getargs_s_hash, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_s_hash, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_s_hash(buffer('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_s_hash(buffer(u'abc\xe9')), + str(buffer(u'abc\xe9'))) + self.assertRaises(TypeError, getargs_s_hash, None) + + def test_t_hash(self): + from _testcapi import getargs_t_hash + self.assertEqual(getargs_t_hash('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_t_hash(u'abc'), 'abc') + self.assertEqual(getargs_t_hash('nul:\0'), 'nul:\0') + self.assertEqual(getargs_t_hash(u'nul:\0'), 'nul:\0') + self.assertRaises(TypeError, getargs_t_hash, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_t_hash, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_t_hash(buffer('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_t_hash(buffer(u'abc')), 'abc') + self.assertRaises(TypeError, getargs_t_hash, None) + + def test_z(self): + from _testcapi import getargs_z + self.assertEqual(getargs_z('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_z(u'abc'), 'abc') + self.assertRaises(TypeError, getargs_z, 'nul:\0') + self.assertRaises(TypeError, getargs_z, u'nul:\0') + self.assertRaises(TypeError, getargs_z, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_z, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_z, buffer('buffer')) + self.assertIsNone(getargs_z(None)) + + def test_z_star(self): + from _testcapi import getargs_z_star + self.assertEqual(getargs_z_star('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_z_star(u'abc'), 'abc') + self.assertEqual(getargs_z_star('nul:\0'), 'nul:\0') + self.assertEqual(getargs_z_star(u'nul:\0'), 'nul:\0') + self.assertEqual(getargs_z_star(bytearray('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_z_star(memoryview('abc\xe9')), 'abc\xe9') + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_z_star(buffer('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_z_star(buffer(u'abc\xe9')), + str(buffer(u'abc\xe9'))) + self.assertIsNone(getargs_z_star(None)) + + def test_z_hash(self): + from _testcapi import getargs_z_hash + self.assertEqual(getargs_z_hash('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_z_hash(u'abc'), 'abc') + self.assertEqual(getargs_z_hash('nul:\0'), 'nul:\0') + self.assertEqual(getargs_z_hash(u'nul:\0'), 'nul:\0') + self.assertRaises(TypeError, getargs_z_hash, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_z_hash, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_z_hash(buffer('abc\xe9')), 'abc\xe9') + self.assertEqual(getargs_z_hash(buffer(u'abc\xe9')), + str(buffer(u'abc\xe9'))) + self.assertIsNone(getargs_z_hash(None)) + + +@test_support.requires_unicode +class Unicode_TestCase(unittest.TestCase): + def test_es(self): + from _testcapi import getargs_es + self.assertEqual(getargs_es('abc'), 'abc') + self.assertEqual(getargs_es(u'abc'), 'abc') + self.assertEqual(getargs_es('abc', 'ascii'), 'abc') + self.assertEqual(getargs_es(u'abc\xe9', 'latin1'), 'abc\xe9') + self.assertRaises(UnicodeEncodeError, getargs_es, u'abc\xe9', 'ascii') + self.assertRaises(LookupError, getargs_es, u'abc', 'spam') + self.assertRaises(TypeError, getargs_es, + bytearray('bytearray'), 'latin1') + self.assertRaises(TypeError, getargs_es, + memoryview('memoryview'), 'latin1') + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_es(buffer('abc'), 'ascii'), 'abc') + self.assertEqual(getargs_es(buffer(u'abc'), 'ascii'), 'abc') + self.assertRaises(TypeError, getargs_es, None, 'latin1') + self.assertRaises(TypeError, getargs_es, 'nul:\0', 'latin1') + self.assertRaises(TypeError, getargs_es, u'nul:\0', 'latin1') + + def test_et(self): + from _testcapi import getargs_et + self.assertEqual(getargs_et('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_et(u'abc'), 'abc') + self.assertEqual(getargs_et('abc', 'ascii'), 'abc') + self.assertEqual(getargs_et('abc\xe9', 'ascii'), 'abc\xe9') + self.assertEqual(getargs_et(u'abc\xe9', 'latin1'), 'abc\xe9') + self.assertRaises(UnicodeEncodeError, getargs_et, u'abc\xe9', 'ascii') + self.assertRaises(LookupError, getargs_et, u'abc', 'spam') + self.assertRaises(TypeError, getargs_et, + bytearray('bytearray'), 'latin1') + self.assertRaises(TypeError, getargs_et, + memoryview('memoryview'), 'latin1') + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_et(buffer('abc'), 'ascii'), 'abc') + self.assertEqual(getargs_et(buffer(u'abc'), 'ascii'), 'abc') + self.assertRaises(TypeError, getargs_et, None, 'latin1') + self.assertRaises(TypeError, getargs_et, 'nul:\0', 'latin1') + self.assertRaises(TypeError, getargs_et, u'nul:\0', 'latin1') + + def test_es_hash(self): + from _testcapi import getargs_es_hash + self.assertEqual(getargs_es_hash('abc'), 'abc') + self.assertEqual(getargs_es_hash(u'abc'), 'abc') + self.assertEqual(getargs_es_hash(u'abc\xe9', 'latin1'), 'abc\xe9') + self.assertRaises(UnicodeEncodeError, getargs_es_hash, u'abc\xe9', 'ascii') + self.assertRaises(LookupError, getargs_es_hash, u'abc', 'spam') + self.assertRaises(TypeError, getargs_es_hash, + bytearray('bytearray'), 'latin1') + self.assertRaises(TypeError, getargs_es_hash, + memoryview('memoryview'), 'latin1') + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_es_hash(buffer('abc'), 'ascii'), 'abc') + self.assertEqual(getargs_es_hash(buffer(u'abc'), 'ascii'), 'abc') + self.assertRaises(TypeError, getargs_es_hash, None, 'latin1') + self.assertEqual(getargs_es_hash('nul:\0', 'latin1'), 'nul:\0') + self.assertEqual(getargs_es_hash(u'nul:\0', 'latin1'), 'nul:\0') + + buf = bytearray('x'*8) + self.assertEqual(getargs_es_hash(u'abc\xe9', 'latin1', buf), 'abc\xe9') + self.assertEqual(buf, bytearray('abc\xe9\x00xxx')) + buf = bytearray('x'*5) + self.assertEqual(getargs_es_hash(u'abc\xe9', 'latin1', buf), 'abc\xe9') + self.assertEqual(buf, bytearray('abc\xe9\x00')) + buf = bytearray('x'*4) + self.assertRaises(TypeError, getargs_es_hash, u'abc\xe9', 'latin1', buf) + self.assertEqual(buf, bytearray('x'*4)) + buf = bytearray() + self.assertRaises(TypeError, getargs_es_hash, u'abc\xe9', 'latin1', buf) + + def test_et_hash(self): + from _testcapi import getargs_et_hash + self.assertEqual(getargs_et_hash('abc\xe9'), 'abc\xe9') + self.assertEqual(getargs_et_hash(u'abc'), 'abc') + self.assertEqual(getargs_et_hash('abc\xe9', 'ascii'), 'abc\xe9') + self.assertEqual(getargs_et_hash(u'abc\xe9', 'latin1'), 'abc\xe9') + self.assertRaises(UnicodeEncodeError, getargs_et_hash, + u'abc\xe9', 'ascii') + self.assertRaises(LookupError, getargs_et_hash, u'abc', 'spam') + self.assertRaises(TypeError, getargs_et_hash, + bytearray('bytearray'), 'latin1') + self.assertRaises(TypeError, getargs_et_hash, + memoryview('memoryview'), 'latin1') + with test_support.check_py3k_warnings(): + self.assertEqual(getargs_et_hash(buffer('abc'), 'ascii'), 'abc') + self.assertEqual(getargs_et_hash(buffer(u'abc'), 'ascii'), 'abc') + self.assertRaises(TypeError, getargs_et_hash, None, 'latin1') + self.assertEqual(getargs_et_hash('nul:\0', 'latin1'), 'nul:\0') + self.assertEqual(getargs_et_hash(u'nul:\0', 'latin1'), 'nul:\0') + + buf = bytearray('x'*8) + self.assertEqual(getargs_et_hash(u'abc\xe9', 'latin1', buf), 'abc\xe9') + self.assertEqual(buf, bytearray('abc\xe9\x00xxx')) + buf = bytearray('x'*5) + self.assertEqual(getargs_et_hash(u'abc\xe9', 'latin1', buf), 'abc\xe9') + self.assertEqual(buf, bytearray('abc\xe9\x00')) + buf = bytearray('x'*4) + self.assertRaises(TypeError, getargs_et_hash, u'abc\xe9', 'latin1', buf) + self.assertEqual(buf, bytearray('x'*4)) + buf = bytearray() + self.assertRaises(TypeError, getargs_et_hash, u'abc\xe9', 'latin1', buf) + + def test_u(self): + from _testcapi import getargs_u + self.assertEqual(getargs_u(u'abc\xe9'), u'abc\xe9') + self.assertEqual(getargs_u(u'nul:\0'), u'nul:') + self.assertRaises(TypeError, getargs_u, 'bytes') + self.assertRaises(TypeError, getargs_u, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_u, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_u, buffer('buffer')) + self.assertRaises(TypeError, getargs_u, None) + + def test_u_hash(self): + from _testcapi import getargs_u_hash + self.assertEqual(getargs_u_hash(u'abc\xe9'), u'abc\xe9') + self.assertEqual(getargs_u_hash(u'nul:\0'), u'nul:\0') + self.assertRaises(TypeError, getargs_u_hash, 'bytes') + self.assertRaises(TypeError, getargs_u_hash, bytearray('bytearray')) + self.assertRaises(TypeError, getargs_u_hash, memoryview('memoryview')) + with test_support.check_py3k_warnings(): + self.assertRaises(TypeError, getargs_u_hash, buffer('buffer')) + self.assertRaises(TypeError, getargs_u_hash, None) + + def test_main(): tests = [Signed_TestCase, Unsigned_TestCase, LongLong_TestCase, - Tuple_TestCase, Keywords_TestCase] + Tuple_TestCase, Keywords_TestCase, + Bytes_TestCase, String_TestCase, Unicode_TestCase] test_support.run_unittest(*tests) if __name__ == "__main__": diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c index 5896e48896..b53ef98c13 100644 --- a/Modules/_testcapimodule.c +++ b/Modules/_testcapimodule.c @@ -1115,6 +1115,267 @@ test_k_code(PyObject *self) return Py_None; } +static PyObject * +getargs_c(PyObject *self, PyObject *args) +{ + char c; + if (!PyArg_ParseTuple(args, "c", &c)) + return NULL; + return PyInt_FromLong((unsigned char)c); +} + +static PyObject * +getargs_s(PyObject *self, PyObject *args) +{ + const char *str; + if (!PyArg_ParseTuple(args, "s", &str)) + return NULL; + return PyBytes_FromString(str); +} + +static PyObject * +getargs_s_star(PyObject *self, PyObject *args) +{ + Py_buffer buffer; + PyObject *bytes; + if (!PyArg_ParseTuple(args, "s*", &buffer)) + return NULL; + bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len); + PyBuffer_Release(&buffer); + return bytes; +} + +static PyObject * +getargs_s_hash(PyObject *self, PyObject *args) +{ + const char *str; + Py_ssize_t size; + if (!PyArg_ParseTuple(args, "s#", &str, &size)) + return NULL; + return PyBytes_FromStringAndSize(str, size); +} + +static PyObject * +getargs_t_hash(PyObject *self, PyObject *args) +{ + const char *str; + Py_ssize_t size; + if (!PyArg_ParseTuple(args, "t#", &str, &size)) + return NULL; + return PyBytes_FromStringAndSize(str, size); +} + +static PyObject * +getargs_z(PyObject *self, PyObject *args) +{ + const char *str; + if (!PyArg_ParseTuple(args, "z", &str)) + return NULL; + if (str != NULL) + return PyBytes_FromString(str); + else + Py_RETURN_NONE; +} + +static PyObject * +getargs_z_star(PyObject *self, PyObject *args) +{ + Py_buffer buffer; + PyObject *bytes; + if (!PyArg_ParseTuple(args, "z*", &buffer)) + return NULL; + if (buffer.buf != NULL) + bytes = PyBytes_FromStringAndSize(buffer.buf, buffer.len); + else { + Py_INCREF(Py_None); + bytes = Py_None; + } + PyBuffer_Release(&buffer); + return bytes; +} + +static PyObject * +getargs_z_hash(PyObject *self, PyObject *args) +{ + const char *str; + Py_ssize_t size; + if (!PyArg_ParseTuple(args, "z#", &str, &size)) + return NULL; + if (str != NULL) + return PyBytes_FromStringAndSize(str, size); + else + Py_RETURN_NONE; +} + +static PyObject * +getargs_w(PyObject *self, PyObject *args) +{ + char *str; + Py_ssize_t size; + + if (!PyArg_ParseTuple(args, "wn", &str, &size)) + return NULL; + + if (2 <= size) { + str[0] = '['; + str[size-1] = ']'; + } + + return PyBytes_FromStringAndSize(str, size); +} + +static PyObject * +getargs_w_hash(PyObject *self, PyObject *args) +{ + char *str; + Py_ssize_t size; + + if (!PyArg_ParseTuple(args, "w#", &str, &size)) + return NULL; + + if (2 <= size) { + str[0] = '['; + str[size-1] = ']'; + } + + return PyBytes_FromStringAndSize(str, size); +} + +static PyObject * +getargs_w_star(PyObject *self, PyObject *args) +{ + Py_buffer buffer; + PyObject *result; + char *str; + + if (!PyArg_ParseTuple(args, "w*", &buffer)) + return NULL; + + if (2 <= buffer.len) { + str = buffer.buf; + str[0] = '['; + str[buffer.len-1] = ']'; + } + + result = PyBytes_FromStringAndSize(buffer.buf, buffer.len); + PyBuffer_Release(&buffer); + return result; +} + +#ifdef Py_USING_UNICODE + +static int +_ustrlen(const Py_UNICODE *u) +{ + int i = 0; + const Py_UNICODE *v = u; + while (*v != 0) { i++; v++; } + return i; +} + +static PyObject * +getargs_u(PyObject *self, PyObject *args) +{ + const Py_UNICODE *str; + Py_ssize_t size; + if (!PyArg_ParseTuple(args, "u", &str)) + return NULL; + size = _ustrlen(str); + return PyUnicode_FromUnicode(str, size); +} + +static PyObject * +getargs_u_hash(PyObject *self, PyObject *args) +{ + const Py_UNICODE *str; + Py_ssize_t size; + if (!PyArg_ParseTuple(args, "u#", &str, &size)) + return NULL; + return PyUnicode_FromUnicode(str, size); +} + +#endif + +static PyObject * +getargs_es(PyObject *self, PyObject *args) +{ + PyObject *arg, *result; + const char *encoding = NULL; + char *str; + + if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding)) + return NULL; + if (!PyArg_Parse(arg, "es", encoding, &str)) + return NULL; + result = PyBytes_FromString(str); + PyMem_Free(str); + return result; +} + +static PyObject * +getargs_et(PyObject *self, PyObject *args) +{ + PyObject *arg, *result; + const char *encoding = NULL; + char *str; + + if (!PyArg_ParseTuple(args, "O|s", &arg, &encoding)) + return NULL; + if (!PyArg_Parse(arg, "et", encoding, &str)) + return NULL; + result = PyBytes_FromString(str); + PyMem_Free(str); + return result; +} + +static PyObject * +getargs_es_hash(PyObject *self, PyObject *args) +{ + PyObject *arg, *result; + const char *encoding = NULL; + PyByteArrayObject *buffer = NULL; + char *str = NULL; + Py_ssize_t size; + + if (!PyArg_ParseTuple(args, "O|sO!", + &arg, &encoding, &PyByteArray_Type, &buffer)) + return NULL; + if (buffer != NULL) { + str = PyByteArray_AS_STRING(buffer); + size = PyByteArray_GET_SIZE(buffer); + } + if (!PyArg_Parse(arg, "es#", encoding, &str, &size)) + return NULL; + result = PyBytes_FromStringAndSize(str, size); + if (buffer == NULL) + PyMem_Free(str); + return result; +} + +static PyObject * +getargs_et_hash(PyObject *self, PyObject *args) +{ + PyObject *arg, *result; + const char *encoding = NULL; + PyByteArrayObject *buffer = NULL; + char *str = NULL; + Py_ssize_t size; + + if (!PyArg_ParseTuple(args, "O|sO!", + &arg, &encoding, &PyByteArray_Type, &buffer)) + return NULL; + if (buffer != NULL) { + str = PyByteArray_AS_STRING(buffer); + size = PyByteArray_GET_SIZE(buffer); + } + if (!PyArg_Parse(arg, "et#", encoding, &str, &size)) + return NULL; + result = PyBytes_FromStringAndSize(str, size); + if (buffer == NULL) + PyMem_Free(str); + return result; +} + #ifdef Py_USING_UNICODE static volatile int x; @@ -1335,7 +1596,12 @@ test_long_numbits(PyObject *self) static PyObject * test_null_strings(PyObject *self) { - PyObject *o1 = PyObject_Str(NULL), *o2 = PyObject_Unicode(NULL); + PyObject *o1 = PyObject_Str(NULL); +#ifdef Py_USING_UNICODE + PyObject *o2 = PyObject_Unicode(NULL); +#else + PyObject *o2 = PyObject_Str(NULL); +#endif PyObject *tuple = PyTuple_Pack(2, o1, o2); Py_XDECREF(o1); Py_XDECREF(o2); @@ -1385,6 +1651,7 @@ set_errno(PyObject *self, PyObject *args) Py_RETURN_NONE; } +#ifdef Py_USING_UNICODE static int test_run_counter = 0; static PyObject * @@ -1407,6 +1674,7 @@ test_datetime_capi(PyObject *self, PyObject *args) { else return NULL; } +#endif #ifdef WITH_THREAD @@ -2045,7 +2313,9 @@ static PyMethodDef TestMethods[] = { {"raise_exception", raise_exception, METH_VARARGS}, {"set_errno", set_errno, METH_VARARGS}, {"test_config", (PyCFunction)test_config, METH_NOARGS}, +#ifdef Py_USING_UNICODE {"test_datetime_capi", test_datetime_capi, METH_NOARGS}, +#endif {"test_list_api", (PyCFunction)test_list_api, METH_NOARGS}, {"test_dict_iteration", (PyCFunction)test_dict_iteration,METH_NOARGS}, {"test_lazy_hash_inheritance", (PyCFunction)test_lazy_hash_inheritance,METH_NOARGS}, @@ -2057,7 +2327,9 @@ static PyMethodDef TestMethods[] = { METH_NOARGS}, {"test_long_numbits", (PyCFunction)test_long_numbits, METH_NOARGS}, {"test_k_code", (PyCFunction)test_k_code, METH_NOARGS}, +#ifdef Py_USING_UNICODE {"test_empty_argparse", (PyCFunction)test_empty_argparse,METH_NOARGS}, +#endif {"test_null_strings", (PyCFunction)test_null_strings, METH_NOARGS}, {"test_string_from_format", (PyCFunction)test_string_from_format, METH_NOARGS}, {"test_with_docstring", (PyCFunction)test_with_docstring, METH_NOARGS, @@ -2082,12 +2354,31 @@ static PyMethodDef TestMethods[] = { {"test_long_long_and_overflow", (PyCFunction)test_long_long_and_overflow, METH_NOARGS}, {"test_L_code", (PyCFunction)test_L_code, METH_NOARGS}, +#endif + {"getargs_c", getargs_c, METH_VARARGS}, + {"getargs_s", getargs_s, METH_VARARGS}, + {"getargs_s_star", getargs_s_star, METH_VARARGS}, + {"getargs_s_hash", getargs_s_hash, METH_VARARGS}, + {"getargs_t_hash", getargs_t_hash, METH_VARARGS}, + {"getargs_z", getargs_z, METH_VARARGS}, + {"getargs_z_star", getargs_z_star, METH_VARARGS}, + {"getargs_z_hash", getargs_z_hash, METH_VARARGS}, + {"getargs_w", getargs_w, METH_VARARGS}, + {"getargs_w_star", getargs_w_star, METH_VARARGS}, + {"getargs_w_hash", getargs_w_hash, METH_VARARGS}, +#ifdef Py_USING_UNICODE + {"getargs_u", getargs_u, METH_VARARGS}, + {"getargs_u_hash", getargs_u_hash, METH_VARARGS}, +#endif + {"getargs_es", getargs_es, METH_VARARGS}, + {"getargs_et", getargs_et, METH_VARARGS}, + {"getargs_es_hash", getargs_es_hash, METH_VARARGS}, + {"getargs_et_hash", getargs_et_hash, METH_VARARGS}, +#ifdef Py_USING_UNICODE {"codec_incrementalencoder", (PyCFunction)codec_incrementalencoder, METH_VARARGS}, {"codec_incrementaldecoder", (PyCFunction)codec_incrementaldecoder, METH_VARARGS}, -#endif -#ifdef Py_USING_UNICODE {"test_u_code", (PyCFunction)test_u_code, METH_NOARGS}, {"test_widechar", (PyCFunction)test_widechar, METH_NOARGS}, {"unicode_encodedecimal", unicode_encodedecimal, METH_VARARGS}, -- 2.50.1