[Python-3000-checkins] r57159 - in python/branches/py3k-buffer: Include/object.h Lib/test/test_xmlrpc.py Modules/arraymodule.c Objects/abstract.c
travis.oliphant
python-3000-checkins at python.org
Fri Aug 17 21:36:16 CEST 2007
Author: travis.oliphant
Date: Fri Aug 17 21:36:15 2007
New Revision: 57159
Added:
python/branches/py3k-buffer/Lib/test/test_xmlrpc.py (contents, props changed)
Modified:
python/branches/py3k-buffer/Include/object.h
python/branches/py3k-buffer/Modules/arraymodule.c
python/branches/py3k-buffer/Objects/abstract.c
Log:
Fix flags and typo.
Modified: python/branches/py3k-buffer/Include/object.h
==============================================================================
--- python/branches/py3k-buffer/Include/object.h (original)
+++ python/branches/py3k-buffer/Include/object.h Fri Aug 17 21:36:15 2007
@@ -147,7 +147,7 @@
Py_ssize_t len;
Py_ssize_t itemsize;
int readonly;
- int ndim
+ int ndim;
char *format;
Py_ssize_t *shape;
Py_ssize_t *strides;
@@ -161,31 +161,31 @@
/* Flags for getting buffers */
#define PyBUF_SIMPLE 0
#define PyBUF_CHARACTER 1
-#define PyBUF_REQ_WRITEABLE 0x0002
-#define PyBUF_REQ_LOCKDATA 0x0004
-#define PyBUF_REQ_FORMAT 0x0008
-#define PyBUF_ALW_ND 0x0010
-#define PyBUF_ALW_STRIDES (0x0020 | PyBUF_ALW_ND)
-#define PyBUF_REQ_C_CONTIGUOUS (0x0040 | PyBUF_ALW_STRIDES)
-#define PyBUF_REQ_F_CONTIGUOUS (0x0080 | PyBUF_ALW_STRIDES)
-#define PyBUF_REQ_ANY_CONTIGUOUS (0x0100 | PyBUF_ALW_STRIDES)
-#define PyBUF_ALW_INDIRECT (0x0200 | PyBUF_ALW_STRIDES)
-
-#define PyBUF_CONTIG (PyBUF_ALW_ND | PyBUF_REQ_WRITEABLE)
-#define PyBUF_CONTIG_RO (PyBUF_ALW_ND)
-#define PyBUF_CONTIG_LCK (PyBUF_ALW_ND | PyBUF_REQ_LOCKDATA)
-
-#define PyBUF_STRIDED (PyBUF_ALW_STRIDES | PyBUF_REQ_WRITEABLE)
-#define PyBUF_STRIDED_RO (PyBUF_ALW_STRIDES)
-#define PyBUF_STRIDED_LCK (PyBUF_ALW_STRIDES | PyBUF_REQ_LOCKDATA)
-
-#define PyBUF_RECORDS (PyBUF_ALW_STRIDES | PyBUF_REQ_WRITEABLE | PyBUF_REQ_FORMAT)
-#define PyBUF_RECORDS_RO (PyBUF_ALW_STRIDES | PyBUF_REQ_FORMAT)
-#define PyBUF_RECORDS_LCK (PyBUF_ALW_STRIDES | PyBUF_REQ_LOCKDATA | PyBUF_REQ_FORMAT)
-
-#define PyBUF_FULL (PyBUF_ALW_INDIRECT | PyBUF_REQ_WRITEABLE | PyBUF_REQ_FORMAT)
-#define PyBUF_FULL_RO (PyBUF_ALW_INDIRECT | PyBUF_REQ_FORMAT)
-#define PyBUF_FULL_LCK (PyBUF_ALW_INDIRECT | PyBUF_REQ_LOCKDATA | PyBUF_REQ_FORMAT)
+#define PyBUF_WRITEABLE 0x0002
+#define PyBUF_LOCKDATA 0x0004
+#define PyBUF_FORMAT 0x0008
+#define PyBUF_ND 0x0010
+#define PyBUF_STRIDES (0x0020 | PyBUF_ND)
+#define PyBUF_C_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
+#define PyBUF_F_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
+#define PyBUF_ANY_CONTIGUOUS (0x0100 | PyBUF_STRIDES)
+#define PyBUF_INDIRECT (0x0200 | PyBUF_STRIDES)
+
+#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITEABLE)
+#define PyBUF_CONTIG_RO (PyBUF_ND)
+#define PyBUF_CONTIG_LCK (PyBUF_ND | PyBUF_LOCKDATA)
+
+#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITEABLE)
+#define PyBUF_STRIDED_RO (PyBUF_STRIDES)
+#define PyBUF_STRIDED_LCK (PyBUF_STRIDES | PyBUF_LOCKDATA)
+
+#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITEABLE | PyBUF_FORMAT)
+#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
+#define PyBUF_RECORDS_LCK (PyBUF_STRIDES | PyBUF_LOCKDATA | PyBUF_FORMAT)
+
+#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITEABLE | PyBUF_FORMAT)
+#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
+#define PyBUF_FULL_LCK (PyBUF_INDIRECT | PyBUF_LOCKDATA | PyBUF_FORMAT)
#define PyBUF_READ 0x100
Added: python/branches/py3k-buffer/Lib/test/test_xmlrpc.py
==============================================================================
--- (empty file)
+++ python/branches/py3k-buffer/Lib/test/test_xmlrpc.py Fri Aug 17 21:36:15 2007
@@ -0,0 +1,348 @@
+import base64
+import datetime
+import sys
+import time
+import unittest
+import xmlrpclib
+import SimpleXMLRPCServer
+import threading
+from test import test_support
+
+alist = [{'astring': 'foo at bar.baz.spam',
+ 'afloat': 7283.43,
+ 'anint': 2**20,
+ 'ashortlong': 2,
+ 'anotherlist': ['.zyx.41'],
+ 'abase64': xmlrpclib.Binary("my dog has fleas"),
+ 'boolean': False,
+ 'unicode': '\u4000\u6000\u8000',
+ 'ukey\u4000': 'regular value',
+ 'datetime1': xmlrpclib.DateTime('20050210T11:41:23'),
+ 'datetime2': xmlrpclib.DateTime(
+ (2005, 2, 10, 11, 41, 23, 0, 1, -1)),
+ 'datetime3': xmlrpclib.DateTime(
+ datetime.datetime(2005, 2, 10, 11, 41, 23)),
+ 'datetime4': xmlrpclib.DateTime(
+ datetime.date(2005, 2, 10)),
+ 'datetime5': xmlrpclib.DateTime(
+ datetime.time(11, 41, 23)),
+ }]
+
+class XMLRPCTestCase(unittest.TestCase):
+
+ def test_dump_load(self):
+ self.assertEquals(alist,
+ xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0])
+
+ def test_dump_bare_datetime(self):
+ # This checks that an unwrapped datetime.date object can be handled
+ # by the marshalling code. This can't be done via test_dump_load()
+ # since with use_datetime set to 1 the unmarshaller would create
+ # datetime objects for the 'datetime[123]' keys as well
+ dt = datetime.datetime(2005, 2, 10, 11, 41, 23)
+ s = xmlrpclib.dumps((dt,))
+ (newdt,), m = xmlrpclib.loads(s, use_datetime=1)
+ self.assertEquals(newdt, dt)
+ self.assertEquals(m, None)
+
+ (newdt,), m = xmlrpclib.loads(s, use_datetime=0)
+ self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23'))
+
+ def test_dump_bare_date(self):
+ # This checks that an unwrapped datetime.date object can be handled
+ # by the marshalling code. This can't be done via test_dump_load()
+ # since the unmarshaller produces a datetime object
+ d = datetime.datetime(2005, 2, 10, 11, 41, 23).date()
+ s = xmlrpclib.dumps((d,))
+ (newd,), m = xmlrpclib.loads(s, use_datetime=1)
+ self.assertEquals(newd.date(), d)
+ self.assertEquals(newd.time(), datetime.time(0, 0, 0))
+ self.assertEquals(m, None)
+
+ (newdt,), m = xmlrpclib.loads(s, use_datetime=0)
+ self.assertEquals(newdt, xmlrpclib.DateTime('20050210T00:00:00'))
+
+ def test_dump_bare_time(self):
+ # This checks that an unwrapped datetime.time object can be handled
+ # by the marshalling code. This can't be done via test_dump_load()
+ # since the unmarshaller produces a datetime object
+ t = datetime.datetime(2005, 2, 10, 11, 41, 23).time()
+ s = xmlrpclib.dumps((t,))
+ (newt,), m = xmlrpclib.loads(s, use_datetime=1)
+ today = datetime.datetime.now().date().strftime("%Y%m%d")
+ self.assertEquals(newt.time(), t)
+ self.assertEquals(newt.date(), datetime.datetime.now().date())
+ self.assertEquals(m, None)
+
+ (newdt,), m = xmlrpclib.loads(s, use_datetime=0)
+ self.assertEquals(newdt, xmlrpclib.DateTime('%sT11:41:23'%today))
+
+ def test_bug_1164912 (self):
+ d = xmlrpclib.DateTime()
+ ((new_d,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((d,),
+ methodresponse=True))
+ self.assert_(isinstance(new_d.value, str))
+
+ # Check that the output of dumps() is still an 8-bit string
+ s = xmlrpclib.dumps((new_d,), methodresponse=True)
+ self.assert_(isinstance(s, str))
+
+ def test_newstyle_class(self):
+ class T(object):
+ pass
+ t = T()
+ t.x = 100
+ t.y = "Hello"
+ ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,)))
+ self.assertEquals(t2, t.__dict__)
+
+ def test_dump_big_long(self):
+ self.assertRaises(OverflowError, xmlrpclib.dumps, (2**99,))
+
+ def test_dump_bad_dict(self):
+ self.assertRaises(TypeError, xmlrpclib.dumps, ({(1,2,3): 1},))
+
+ def test_dump_recursive_seq(self):
+ l = [1,2,3]
+ t = [3,4,5,l]
+ l.append(t)
+ self.assertRaises(TypeError, xmlrpclib.dumps, (l,))
+
+ def test_dump_recursive_dict(self):
+ d = {'1':1, '2':1}
+ t = {'3':3, 'd':d}
+ d['t'] = t
+ self.assertRaises(TypeError, xmlrpclib.dumps, (d,))
+
+ def test_dump_big_int(self):
+ if sys.maxint > 2**31-1:
+ self.assertRaises(OverflowError, xmlrpclib.dumps,
+ (int(2**34),))
+
+ xmlrpclib.dumps((xmlrpclib.MAXINT, xmlrpclib.MININT))
+ self.assertRaises(OverflowError, xmlrpclib.dumps, (xmlrpclib.MAXINT+1,))
+ self.assertRaises(OverflowError, xmlrpclib.dumps, (xmlrpclib.MININT-1,))
+
+ def dummy_write(s):
+ pass
+
+ m = xmlrpclib.Marshaller()
+ m.dump_int(xmlrpclib.MAXINT, dummy_write)
+ m.dump_int(xmlrpclib.MININT, dummy_write)
+ self.assertRaises(OverflowError, m.dump_int, xmlrpclib.MAXINT+1, dummy_write)
+ self.assertRaises(OverflowError, m.dump_int, xmlrpclib.MININT-1, dummy_write)
+
+
+ def test_dump_none(self):
+ value = alist + [None]
+ arg1 = (alist + [None],)
+ strg = xmlrpclib.dumps(arg1, allow_none=True)
+ self.assertEquals(value,
+ xmlrpclib.loads(strg)[0][0])
+ self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,))
+
+
+class HelperTestCase(unittest.TestCase):
+ def test_escape(self):
+ self.assertEqual(xmlrpclib.escape("a&b"), "a&b")
+ self.assertEqual(xmlrpclib.escape("a<b"), "a<b")
+ self.assertEqual(xmlrpclib.escape("a>b"), "a>b")
+
+class FaultTestCase(unittest.TestCase):
+ def test_repr(self):
+ f = xmlrpclib.Fault(42, 'Test Fault')
+ self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
+ self.assertEqual(repr(f), str(f))
+
+ def test_dump_fault(self):
+ f = xmlrpclib.Fault(42, 'Test Fault')
+ s = xmlrpclib.dumps((f,))
+ (newf,), m = xmlrpclib.loads(s)
+ self.assertEquals(newf, {'faultCode': 42, 'faultString': 'Test Fault'})
+ self.assertEquals(m, None)
+
+ s = xmlrpclib.Marshaller().dumps(f)
+ self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s)
+
+
+class DateTimeTestCase(unittest.TestCase):
+ def test_default(self):
+ t = xmlrpclib.DateTime()
+
+ def test_time(self):
+ d = 1181399930.036952
+ t = xmlrpclib.DateTime(d)
+ self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", time.localtime(d)))
+
+ def test_time_tuple(self):
+ d = (2007,6,9,10,38,50,5,160,0)
+ t = xmlrpclib.DateTime(d)
+ self.assertEqual(str(t), '20070609T10:38:50')
+
+ def test_time_struct(self):
+ d = time.localtime(1181399930.036952)
+ t = xmlrpclib.DateTime(d)
+ self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d))
+
+ def test_datetime_datetime(self):
+ d = datetime.datetime(2007,1,2,3,4,5)
+ t = xmlrpclib.DateTime(d)
+ self.assertEqual(str(t), '20070102T03:04:05')
+
+ def test_datetime_date(self):
+ d = datetime.date(2007,9,8)
+ t = xmlrpclib.DateTime(d)
+ self.assertEqual(str(t), '20070908T00:00:00')
+
+ def test_datetime_time(self):
+ d = datetime.time(13,17,19)
+ # allow for date rollover by checking today's or tomorrow's dates
+ dd1 = datetime.datetime.now().date()
+ dd2 = dd1 + datetime.timedelta(days=1)
+ vals = (dd1.strftime('%Y%m%dT13:17:19'),
+ dd2.strftime('%Y%m%dT13:17:19'))
+ t = xmlrpclib.DateTime(d)
+ self.assertEqual(str(t) in vals, True)
+
+ def test_repr(self):
+ d = datetime.datetime(2007,1,2,3,4,5)
+ t = xmlrpclib.DateTime(d)
+ val ="<DateTime '20070102T03:04:05' at %x>" % id(t)
+ self.assertEqual(repr(t), val)
+
+ def test_decode(self):
+ d = ' 20070908T07:11:13 '
+ t1 = xmlrpclib.DateTime()
+ t1.decode(d)
+ tref = xmlrpclib.DateTime(datetime.datetime(2007,9,8,7,11,13))
+ self.assertEqual(t1, tref)
+
+ t2 = xmlrpclib._datetime(d)
+ self.assertEqual(t1, tref)
+
+class BinaryTestCase(unittest.TestCase):
+ def test_default(self):
+ t = xmlrpclib.Binary()
+ self.assertEqual(str(t), '')
+
+ def test_string(self):
+ d = '\x01\x02\x03abc123\xff\xfe'
+ t = xmlrpclib.Binary(d)
+ self.assertEqual(str(t), d)
+
+ def test_decode(self):
+ d = '\x01\x02\x03abc123\xff\xfe'
+ de = base64.encodestring(d)
+ t1 = xmlrpclib.Binary()
+ t1.decode(de)
+ self.assertEqual(str(t1), d)
+
+ t2 = xmlrpclib._binary(de)
+ self.assertEqual(str(t2), d)
+
+
+PORT = None
+
+def http_server(evt, numrequests):
+ class TestInstanceClass:
+ def div(self, x, y):
+ '''This is the div function'''
+ return x // y
+
+
+ serv = SimpleXMLRPCServer.SimpleXMLRPCServer(("localhost", 0),
+ logRequests=False, bind_and_activate=False)
+
+ try:
+ serv.socket.settimeout(3)
+ serv.server_bind()
+ global PORT
+ PORT = serv.socket.getsockname()[1]
+ serv.server_activate()
+ serv.register_introspection_functions()
+ serv.register_multicall_functions()
+ serv.register_function(pow)
+ serv.register_function(lambda x,y: x+y, 'add')
+ serv.register_instance(TestInstanceClass())
+
+ # handle up to 'numrequests' requests
+ while numrequests > 0:
+ serv.handle_request()
+ numrequests -= 1
+
+ except socket.timeout:
+ pass
+ finally:
+ serv.socket.close()
+ PORT = None
+ evt.set()
+
+
+class HTTPTestCase(unittest.TestCase):
+ def setUp(self):
+ self.evt = threading.Event()
+ # start server thread to handle just one request
+ threading.Thread(target=http_server, args=(self.evt,2)).start()
+
+ # wait for port to be assigned to server
+ n = 1000
+ while n > 0 and PORT is None:
+ time.sleep(0.001)
+ n -= 1
+
+ time.sleep(0.5)
+
+ def tearDown(self):
+ # wait on the server thread to terminate
+ self.evt.wait()
+
+ def test_simple1(self):
+ p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
+ self.assertEqual(p.pow(6,8), 6**8)
+
+ def test_introspection1(self):
+ p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
+ meth = p.system.listMethods()
+ expected_methods = set(['pow', 'div', 'add', 'system.listMethods',
+ 'system.methodHelp', 'system.methodSignature', 'system.multicall'])
+ self.assertEqual(set(meth), expected_methods)
+
+ def test_introspection2(self):
+ p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
+ divhelp = p.system.methodHelp('div')
+ self.assertEqual(divhelp, 'This is the div function')
+
+ def test_introspection3(self):
+ # the SimpleXMLRPCServer doesn't support signatures, but
+ # at least check that we can try
+ p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
+ divsig = p.system.methodSignature('div')
+ self.assertEqual(divsig, 'signatures not supported')
+
+ def test_multicall(self):
+ p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
+ multicall = xmlrpclib.MultiCall(p)
+ multicall.add(2,3)
+ multicall.pow(6,8)
+ multicall.div(127,42)
+ add_result, pow_result, div_result = multicall()
+ self.assertEqual(add_result, 2+3)
+ self.assertEqual(pow_result, 6**8)
+ self.assertEqual(div_result, 127//42)
+
+
+def test_main():
+ xmlrpc_tests = [XMLRPCTestCase, HelperTestCase, DateTimeTestCase,
+ BinaryTestCase, FaultTestCase]
+
+ # The test cases against a SimpleXMLRPCServer raise a socket error
+ # 10035 (WSAEWOULDBLOCK) in the server thread handle_request call when
+ # run on Windows. This only happens on the first test to run, but it
+ # fails every time and so these tests are skipped on win32 platforms.
+ if sys.platform != 'win32':
+ xmlrpc_tests.append(HTTPTestCase)
+
+ test_support.run_unittest(*xmlrpc_tests)
+
+if __name__ == "__main__":
+ test_main()
Modified: python/branches/py3k-buffer/Modules/arraymodule.c
==============================================================================
--- python/branches/py3k-buffer/Modules/arraymodule.c (original)
+++ python/branches/py3k-buffer/Modules/arraymodule.c Fri Aug 17 21:36:15 2007
@@ -1740,7 +1740,7 @@
static int
array_buffer_getbuf(arrayobject *self, PyBuffer *view, int flags)
{
- if ((flags & PyBUF_REQ_LOCKDATA)) {
+ if ((flags & PyBUF_LOCKDATA)) {
PyErr_SetString(PyExc_BufferError,
"Cannot lock data");
return -1;
@@ -1754,15 +1754,15 @@
view->itemsize = self->ob_descr->itemsize;
view->suboffsets = NULL;
view->shape = NULL;
- if ((flags & PyBUF_ALW_ND)==PyBUF_ALW_ND) {
+ if ((flags & PyBUF_ND)==PyBUF_ND) {
view->shape = &((Py_Size(self)));
}
view->strides = NULL;
- if ((flags & PyBUF_ALW_STRIDES)==PyBUF_ALW_STRIDES)
+ if ((flags & PyBUF_STRIDES)==PyBUF_STRIDES)
view->strides = &(view->itemsize);
view->format = NULL;
view->internal = NULL;
- if ((flags & PyBUF_REQ_FORMAT) == PyBUF_REQ_FORMAT) {
+ if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
view->internal = malloc(3);
view->format = view->internal;
view->format[0] = (char)(self->ob_descr->typecode);
Modified: python/branches/py3k-buffer/Objects/abstract.c
==============================================================================
--- python/branches/py3k-buffer/Objects/abstract.c (original)
+++ python/branches/py3k-buffer/Objects/abstract.c Fri Aug 17 21:36:15 2007
@@ -304,7 +304,7 @@
pb = obj->ob_type->tp_as_buffer;
if (pb == NULL ||
pb->bf_getbuffer == NULL ||
- ((*pb->bf_getbuffer)(obj, &view, PyBUF_REQ_WRITEABLE) != 0)) {
+ ((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITEABLE) != 0)) {
PyErr_SetString(PyExc_TypeError,
"expected an object with a writeable buffer interface");
return -1;
@@ -649,13 +649,13 @@
int readonly, int flags)
{
if (view == NULL) return 0;
- if (((flags & PyBUF_REQ_LOCKDATA) == PyBUF_REQ_LOCKDATA) &&
+ if (((flags & PyBUF_LOCKDATA) == PyBUF_LOCKDATA) &&
readonly != -1) {
PyErr_SetString(PyExc_BufferError,
"Cannot make this object read-only.");
return -1;
}
- if (((flags & PyBUF_REQ_WRITEABLE) == PyBUF_REQ_WRITEABLE) &&
+ if (((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE) &&
readonly == 1) {
PyErr_SetString(PyExc_BufferError,
"Object is not writeable.");
@@ -667,14 +667,14 @@
view->readonly = readonly;
view->itemsize = 1;
view->format = NULL;
- if ((flags & PyBUF_REQ_FORMAT) == PyBUF_REQ_FORMAT)
+ if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
view->format = "B";
view->ndim = 1;
view->shape = NULL;
- if ((flags & PyBUF_ALW_ND) == PyBUF_ALW_ND)
+ if ((flags & PyBUF_ND) == PyBUF_ND)
view->shape = &(view->len);
view->strides = NULL;
- if ((flags & PyBUF_ALW_STRIDES) == PyBUF_ALW_STRIDES)
+ if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)
view->strides = &(view->itemsize);
view->suboffsets = NULL;
view->internal = NULL;
More information about the Python-3000-checkins
mailing list