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

@@ -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__":

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},