c_char, c_char_p objects and c_char array structure fields return

their value now as str, no longer str8.

Lib/ctypes/test/test_buffers.py

@@ -7,12 +7,12 @@ class StringBufferTestCase(unittest.TestCase):
         b = create_string_buffer(32)
         self.failUnlessEqual(len(b), 32)
         self.failUnlessEqual(sizeof(b), 32 * sizeof(c_char))
-        self.failUnless(type(b[0]) is str8)
+        self.failUnless(type(b[0]) is str)
 
         b = create_string_buffer("abc")
         self.failUnlessEqual(len(b), 4) # trailing nul char
         self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char))
-        self.failUnless(type(b[0]) is str8)
+        self.failUnless(type(b[0]) is str)
         self.failUnlessEqual(b[0], "a")
         self.failUnlessEqual(b[:], "abc\0")
 
@@ -20,7 +20,7 @@ class StringBufferTestCase(unittest.TestCase):
         b = create_string_buffer("abc")
         self.failUnlessEqual(len(b), 4) # trailing nul char
         self.failUnlessEqual(sizeof(b), 4 * sizeof(c_char))
-        self.failUnless(type(b[0]) is str8)
+        self.failUnless(type(b[0]) is str)
         self.failUnlessEqual(b[0], "a")
         self.failUnlessEqual(b[:], "abc\0")
 

Lib/ctypes/test/test_bytes.py

@@ -29,14 +29,18 @@ class BytesTest(unittest.TestCase):
             _fields_ = [("a", c_char * 3)]
 
         X("abc")
-        X(b"abc")
+        x = X(b"abc")
+        self.assertEqual(x.a, "abc")
+        self.assertEqual(type(x.a), str)
 
     def test_struct_W(self):
         class X(Structure):
             _fields_ = [("a", c_wchar * 3)]
 
         X("abc")
-        X(b"abc")
+        x = X(b"abc")
+        self.assertEqual(x.a, "abc")
+        self.assertEqual(type(x.a), str)
 
     if sys.platform == "win32":
         def test_BSTR(self):

Lib/ctypes/test/test_objects.py

@@ -24,7 +24,7 @@ assigned from Python must be kept.
 >>> array._objects
 {'4': b'foo bar'}
 >>> array[4]
-s'foo bar'
+'foo bar'
 >>>
 
 It gets more complicated when the ctypes instance itself is contained

Lib/ctypes/test/test_random_things.py

@@ -69,7 +69,7 @@ class CallbackTracbackTestCase(unittest.TestCase):
         out = self.capture_stderr(cb, "spam")
         self.failUnlessEqual(out.splitlines()[-1],
                              "TypeError: "
-                             "unsupported operand type(s) for /: 'int' and 'str8'")
+                             "unsupported operand type(s) for /: 'int' and 'str'")
 
 if __name__ == '__main__':
     unittest.main()

Lib/ctypes/test/test_repr.py

@@ -22,7 +22,7 @@ class ReprTest(unittest.TestCase):
             self.failUnlessEqual("<X object at", repr(typ(42))[:12])
 
     def test_char(self):
-        self.failUnlessEqual("c_char(s'x')", repr(c_char('x')))
+        self.failUnlessEqual("c_char('x')", repr(c_char('x')))
         self.failUnlessEqual("<X object at", repr(X('x'))[:12])
 
 if __name__ == "__main__":

Lib/ctypes/test/test_slicing.py

@@ -70,7 +70,7 @@ class SlicesTestCase(unittest.TestCase):
         dll.my_strdup.errcheck = errcheck
         try:
             res = dll.my_strdup(s)
-            self.failUnlessEqual(res, s)
+            self.failUnlessEqual(res, str(s))
         finally:
             del dll.my_strdup.errcheck
 

Modules/_ctypes/cfield.c

@@ -1137,9 +1137,7 @@ c_set(void *ptr, PyObject *value, Py_ssize_t size)
 			return NULL;
 		if (PyBytes_GET_SIZE(value) != 1) {
 			Py_DECREF(value);
-			PyErr_Format(PyExc_TypeError,
-				     "one character string expected");
-			return NULL;
+			goto error;
 		}
 		*(char *)ptr = PyBytes_AsString(value)[0];
 		Py_DECREF(value);
@@ -1149,22 +1147,17 @@ c_set(void *ptr, PyObject *value, Py_ssize_t size)
 		*(char *)ptr = PyBytes_AsString(value)[0];
 		_RET(value);
 	}
-	/* XXX struni remove later */
-	if (!PyString_Check(value) || (1 != PyString_Size(value))) {
-		PyErr_Format(PyExc_TypeError,
-			     "one character string expected");
-		return NULL;
-	}
-	*(char *)ptr = PyString_AS_STRING(value)[0];
-	_RET(value);
+  error:
+	PyErr_Format(PyExc_TypeError,
+		     "one character string expected");
+	return NULL;
 }
 
 
 static PyObject *
 c_get(void *ptr, Py_ssize_t size)
 {
-	/* XXX struni return PyBytes (or PyUnicode?) later */
-	return PyString_FromStringAndSize((char *)ptr, 1);
+	return PyUnicode_FromStringAndSize((char *)ptr, 1);
 }
 
 #ifdef CTYPES_UNICODE
@@ -1280,24 +1273,16 @@ U_set(void *ptr, PyObject *value, Py_ssize_t length)
 static PyObject *
 s_get(void *ptr, Py_ssize_t size)
 {
-	PyObject *result;
-	size_t slen;
+	Py_ssize_t i;
+	char *p;
 
-	result = PyString_FromString((char *)ptr);
-	if (!result)
-		return NULL;
-	/* chop off at the first NUL character, if any.
-	 * On error, result will be deallocated and set to NULL.
-	 */
-	slen = strlen(PyString_AS_STRING(result));
-	size = min(size, (Py_ssize_t)slen);
-	if (result->ob_refcnt == 1) {
-		/* shorten the result */
-		_PyString_Resize(&result, size);
-		return result;
-	} else
-		/* cannot shorten the result */
-		return PyString_FromStringAndSize(ptr, size);
+	p = (char *)ptr;
+	for (i = 0; i < size; ++i) {
+		if (*p++ == '\0')
+			break;
+	}
+
+	return PyUnicode_FromStringAndSize((char *)ptr, (Py_ssize_t)i);
 }
 
 static PyObject *
@@ -1393,7 +1378,7 @@ z_get(void *ptr, Py_ssize_t size)
 			return NULL;
 		}
 #endif
-		return PyString_FromString(*(char **)ptr);
+		return PyUnicode_FromString(*(char **)ptr);
 	} else {
 		Py_INCREF(Py_None);
 		return Py_None;