[Python-checkins] cpython (2.7): Issue #26198: Added tests for string-related format units of PyArg_Parse*()
serhiy.storchaka
python-checkins at python.org
Thu Jan 28 12:57:58 EST 2016
https://hg.python.org/cpython/rev/60a2d67dacb3
changeset: 100099:60a2d67dacb3
branch: 2.7
parent: 100076:34ca24fa1b4a
user: Serhiy Storchaka <storchaka at gmail.com>
date: Thu Jan 28 19:56:04 2016 +0200
summary:
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".
files:
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
--- a/Lib/test/test_getargs2.py
+++ b/Lib/test/test_getargs2.py
@@ -331,9 +331,293 @@
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))
+
+
+ at 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
--- a/Modules/_testcapimodule.c
+++ b/Modules/_testcapimodule.c
@@ -1115,6 +1115,267 @@
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 @@
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 @@
Py_RETURN_NONE;
}
+#ifdef Py_USING_UNICODE
static int test_run_counter = 0;
static PyObject *
@@ -1407,6 +1674,7 @@
else
return NULL;
}
+#endif
#ifdef WITH_THREAD
@@ -2045,7 +2313,9 @@
{"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 @@
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 @@
{"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},
--
Repository URL: https://hg.python.org/cpython
More information about the Python-checkins
mailing list