Run all test cases.
"""
import sys
+import time
import unittest
import test.test_support
from test.test_support import requires, run_unittest, unlink
sys.argv.remove('silent')
+class TimingCheck(unittest.TestCase):
+
+ """This class is not a real test. Its purpose is to print a message
+ periodically when the test runs slowly. This will prevent the buildbots
+ from timing out on slow machines."""
+
+ # How much time in seconds before printing a 'Still working' message.
+ # Since this is run at most once between each test module, use a smaller
+ # interval than other tests.
+ _PRINT_WORKING_MSG_INTERVAL = 4 * 60
+
+ # next_time is used as a global variable that survives each instance.
+ # This is necessary since a new instance will be created for each test.
+ next_time = time.time() + _PRINT_WORKING_MSG_INTERVAL
+
+ def testCheckElapsedTime(self):
+ # Print still working message since these tests can be really slow.
+ now = time.time()
+ if self.next_time <= now:
+ TimingCheck.next_time = now + self._PRINT_WORKING_MSG_INTERVAL
+ sys.__stdout__.write(' test_bsddb3 still working, be patient...\n')
+ sys.__stdout__.flush()
+
+
def suite():
try:
# this is special, it used to segfault the interpreter
module = __import__("bsddb.test."+name, globals(), locals(), name)
#print module,name
alltests.addTest(module.test_suite())
+ alltests.addTest(unittest.makeSuite(TimingCheck))
return alltests
import unittest
from test import test_support
-
-import os, resource
+import os
+import resource
+import time
# This test is checking a few specific problem spots with the resource module.
# an attempt to ensure the file is really synced and
# the exception raised.
for i in range(5):
+ time.sleep(.1)
+ f.flush()
f.close()
except IOError:
if not limit_set:
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
self.assertEqual(p.pow(6,8), 6**8)
- except xmlrpclib.ProtocolError as e:
- # protocol error; provide additional information in test output
- self.fail("%s\n%s" % (e, e.headers))
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # protocol error; provide additional information in test output
+ self.fail("%s\n%s" % (e, e.headers))
# [ch] The test 404 is causing lots of false alarms.
def XXXtest_404(self):
'system.listMethods', 'system.methodHelp',
'system.methodSignature', 'system.multicall'])
self.assertEqual(set(meth), expected_methods)
- except xmlrpclib.ProtocolError as e:
- # protocol error; provide additional information in test output
- self.fail("%s\n%s" % (e, e.headers))
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # protocol error; provide additional information in test output
+ self.fail("%s\n%s" % (e, e.headers))
+
def test_introspection2(self):
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
divhelp = p.system.methodHelp('div')
self.assertEqual(divhelp, 'This is the div function')
- except xmlrpclib.ProtocolError as e:
- # protocol error; provide additional information in test output
- self.fail("%s\n%s" % (e, e.headers))
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # protocol error; provide additional information in test output
+ self.fail("%s\n%s" % (e, e.headers))
def test_introspection3(self):
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
myfunction = p.system.methodHelp('my_function')
self.assertEqual(myfunction, 'This is my function')
- except xmlrpclib.ProtocolError as e:
+ except (xmlrpclib.ProtocolError, socket.error) as e:
# ignore failures due to non-blocking socket 'unavailable' errors
if not is_unavailable_exception(e):
# protocol error; provide additional information in test output
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
divsig = p.system.methodSignature('div')
self.assertEqual(divsig, 'signatures not supported')
- except xmlrpclib.ProtocolError as e:
- # protocol error; provide additional information in test output
- self.fail("%s\n%s" % (e, e.headers))
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # protocol error; provide additional information in test output
+ self.fail("%s\n%s" % (e, e.headers))
def test_multicall(self):
try:
self.assertEqual(add_result, 2+3)
self.assertEqual(pow_result, 6**8)
self.assertEqual(div_result, 127//42)
- except xmlrpclib.ProtocolError as e:
- # protocol error; provide additional information in test output
- self.fail("%s\n%s" % (e, e.headers))
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # protocol error; provide additional information in test output
+ self.fail("%s\n%s" % (e, e.headers))
def test_non_existing_multicall(self):
try:
self.assertEqual(result.results[0]['faultString'],
'<type \'Exception\'>:method "this_is_not_exists" '
'is not supported')
- except xmlrpclib.ProtocolError as e:
+ except (xmlrpclib.ProtocolError, socket.error) as e:
# ignore failures due to non-blocking socket 'unavailable' errors
if not is_unavailable_exception(e):
# protocol error; provide additional information in test output
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
self.assertEqual(p.pow(6,8), 6**8)
- except xmlrpclib.ProtocolError as e:
- # protocol error; provide additional information in test output
- self.fail("%s\n%s" % (e, e.headers))
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # protocol error; provide additional information in test output
+ self.fail("%s\n%s" % (e, e.headers))
def test_fail_no_info(self):
# use the broken message class
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
p.pow(6,8)
- except xmlrpclib.ProtocolError as e:
- # The two server-side error headers shouldn't be sent back in this case
- self.assertTrue(e.headers.get("X-exception") is None)
- self.assertTrue(e.headers.get("X-traceback") is None)
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # The two server-side error headers shouldn't be sent back in this case
+ self.assertTrue(e.headers.get("X-exception") is None)
+ self.assertTrue(e.headers.get("X-traceback") is None)
else:
self.fail('ProtocolError not raised')
try:
p = xmlrpclib.ServerProxy('http://localhost:%d' % PORT)
p.pow(6,8)
- except xmlrpclib.ProtocolError as e:
- # We should get error info in the response
- expected_err = "invalid literal for int() with base 10: 'I am broken'"
- self.assertEqual(e.headers.get("x-exception"), expected_err)
- self.assertTrue(e.headers.get("x-traceback") is not None)
+ except (xmlrpclib.ProtocolError, socket.error) as e:
+ # ignore failures due to non-blocking socket 'unavailable' errors
+ if not is_unavailable_exception(e):
+ # We should get error info in the response
+ expected_err = "invalid literal for int() with base 10: 'I am broken'"
+ self.assertEqual(e.headers.get("x-exception"), expected_err)
+ self.assertTrue(e.headers.get("x-traceback") is not None)
else:
self.fail('ProtocolError not raised')
#include <ffi.h>
#include <ffi_common.h>
-
#include <stdlib.h>
-extern void ffi_call_osf(void *, unsigned long, unsigned, void *, void (*)(void));
-extern void ffi_closure_osf(void);
+/* Force FFI_TYPE_LONGDOUBLE to be different than FFI_TYPE_DOUBLE;
+ all further uses in this file will refer to the 128-bit type. */
+#if defined(__LONG_DOUBLE_128__)
+# if FFI_TYPE_LONGDOUBLE != 4
+# error FFI_TYPE_LONGDOUBLE out of date
+# endif
+#else
+# undef FFI_TYPE_LONGDOUBLE
+# define FFI_TYPE_LONGDOUBLE 4
+#endif
+
+extern void ffi_call_osf(void *, unsigned long, unsigned, void *, void (*)(void))
+ FFI_HIDDEN;
+extern void ffi_closure_osf(void) FFI_HIDDEN;
ffi_status
cif->flags = cif->rtype->type;
break;
+ case FFI_TYPE_LONGDOUBLE:
+ /* 128-bit long double is returned in memory, like a struct. */
+ cif->flags = FFI_TYPE_STRUCT;
+ break;
+
default:
cif->flags = FFI_TYPE_INT;
break;
return FFI_OK;
}
+
void
ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
{
long i, avn;
ffi_type **arg_types;
- FFI_ASSERT (cif->abi == FFI_OSF);
-
/* If the return value is a struct and we don't have a return
value address then we need to make one. */
if (rvalue == NULL && cif->flags == FFI_TYPE_STRUCT)
while (i < avn)
{
+ size_t size = (*arg_types)->size;
+
switch ((*arg_types)->type)
{
case FFI_TYPE_SINT8:
*(double *) argp = *(double *)(* avalue);
break;
+ case FFI_TYPE_LONGDOUBLE:
+ /* 128-bit long double is passed by reference. */
+ *(long double **) argp = (long double *)(* avalue);
+ size = sizeof (long double *);
+ break;
+
case FFI_TYPE_STRUCT:
memcpy(argp, *avalue, (*arg_types)->size);
break;
FFI_ASSERT(0);
}
- argp += ALIGN((*arg_types)->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
+ argp += ALIGN(size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
i++, arg_types++, avalue++;
}
{
unsigned int *tramp;
- FFI_ASSERT (cif->abi == FFI_OSF);
-
tramp = (unsigned int *) &closure->tramp[0];
tramp[0] = 0x47fb0401; /* mov $27,$1 */
tramp[1] = 0xa77b0010; /* ldq $27,16($27) */
return FFI_OK;
}
-int
+
+long FFI_HIDDEN
ffi_closure_osf_inner(ffi_closure *closure, void *rvalue, unsigned long *argp)
{
ffi_cif *cif;
/* Grab the addresses of the arguments from the stack frame. */
while (i < avn)
{
+ size_t size = arg_types[i]->size;
+
switch (arg_types[i]->type)
{
case FFI_TYPE_SINT8:
avalue[i] = &argp[argn - (argn < 6 ? 6 : 0)];
break;
+ case FFI_TYPE_LONGDOUBLE:
+ /* 128-bit long double is passed by reference. */
+ avalue[i] = (long double *) argp[argn];
+ size = sizeof (long double *);
+ break;
+
default:
- FFI_ASSERT(0);
+ abort ();
}
- argn += ALIGN(arg_types[i]->size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
+ argn += ALIGN(size, FFI_SIZEOF_ARG) / FFI_SIZEOF_ARG;
i++;
}
/* Invoke the closure. */
- (closure->fun) (cif, rvalue, avalue, closure->user_data);
+ closure->fun (cif, rvalue, avalue, closure->user_data);
/* Tell ffi_closure_osf how to perform return type promotions. */
return cif->rtype->type;
/* -----------------------------------------------------------------------
- osf.S - Copyright (c) 1998, 2001 Red Hat
+ osf.S - Copyright (c) 1998, 2001, 2007 Red Hat
Alpha/OSF Foreign Function Interface
- $Id: osf.S,v 1.2 2006/03/03 20:24:26 theller Exp $
-
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
``Software''), to deal in the Software without restriction, including
.align 3
.globl ffi_call_osf
.ent ffi_call_osf
+ FFI_HIDDEN(ffi_call_osf)
+
ffi_call_osf:
.frame $15, 32, $26, 0
.mask 0x4008000, -32
.align 3
.globl ffi_closure_osf
.ent ffi_closure_osf
+ FFI_HIDDEN(ffi_closure_osf)
+
ffi_closure_osf:
.frame $30, 16*8, $26, 0
.mask 0x4000000, -16*8
.gprel32 $load_32 # FFI_TYPE_INT
.gprel32 $load_float # FFI_TYPE_FLOAT
.gprel32 $load_double # FFI_TYPE_DOUBLE
- .gprel32 $load_double # FFI_TYPE_LONGDOUBLE
+ .gprel32 $load_none # FFI_TYPE_LONGDOUBLE
.gprel32 $load_u8 # FFI_TYPE_UINT8
.gprel32 $load_s8 # FFI_TYPE_SINT8
.gprel32 $load_u16 # FFI_TYPE_UINT16
}
p = ext->value->data;
- if(method->it)
+ if (method->it)
names = (GENERAL_NAMES*)
(ASN1_item_d2i(NULL,
&p,
PyObject *raw, *ref;
Py_ssize_t i, n;
- if(!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
+ if (!PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG))
return;
raw = type->tp_subclasses;
Py_ssize_t i, n;
int clear = 0;
- if(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))
+ if (!PyType_HasFeature(type, Py_TPFLAGS_HAVE_VERSION_TAG))
return;
n = PyTuple_GET_SIZE(bases);
PyObject *bases, *result;
PyObject *to_merge, *bases_aslist;
- if(type->tp_dict == NULL) {
- if(PyType_Ready(type) < 0)
+ if (type->tp_dict == NULL) {
+ if (PyType_Ready(type) < 0)
return NULL;
}
unsigned int h;
if (MCACHE_CACHEABLE_NAME(name) &&
- PyType_HasFeature(type,Py_TPFLAGS_VALID_VERSION_TAG)) {
+ PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {
/* fast path */
h = MCACHE_HASH_METHOD(type, name);
if (method_cache[h].version == type->tp_version_tag &&
for (s = str;; s++) {
if (*s == '\0') break;
else if (*s == '\n') {
+ assert(lineno < 2);
newl[lineno] = s;
lineno++;
if (lineno == 2) break;
else {
/* This check is expensive! */
if (PyErr_Occurred()) {
- char buf[1024];
+ char buf[128];
sprintf(buf, "Stack unwind with exception "
"set and why=%d", why);
Py_FatalError(buf);
projects / python / commitdiff