foo (float xf, double x, long double xl,
float yf, double y, long double yl,
int i, int j)
{
TEST_EQ(fmin);
TEST_EQ(fmax);
#ifdef __OPTIMIZE__
TEST_EQ_PURE(fmin);
TEST_EQ_PURE(fmax);
#endif
TEST_INT(fmin);
TEST_INT(fmax);
TEST_NONNEG(fmin);
TEST_NONNEG(fmax);
TEST_NAN(fmin,);
TEST_NAN(fmax,);
TEST_NAN(fmin,s);
TEST_NAN(fmax,s);
}
void
test_uint (CharT*, Traits*,
const char *cname,
const char *tname)
{
info (cname, tname, "unsigned int");
test_extractor ((CharT*)0, (Traits*)0, (unsigned int*)0,
cname, tname, "unsigned int", "%u");
#define TEST_UINT(ss, fl, is, ex, ee, es, ne, fw, iv, ev) \
TEST (int, "%u", ss, fl, is, ex, ee, es, ne, fw, iv, ev)
LocaleData locale_data = { 0, -1, -1, 0, 0, 0 };
locale_data.whitespace = "";
#if 2 == _RWSTD_UINT_SIZE
const unsigned uimax = 65535U;
TEST_INT ("65535", -1, -1, -1, 0, _e_, 5, 0, 1, uimax);
TEST_INT ("65536", -1, -1, -1, 0, _ef, 5, 0, 1, uimax);
TEST_INT ("99999", -1, -1, -1, 0, _ef, 5, 0, 1, uimax);
#elif 4 == _RWSTD_UINT_SIZE
const unsigned uimax = 4294967295U;
TEST_INT ("4294967295", -1, -1, -1, 0, _e_, 10, 0, -1, uimax);
TEST_INT ("4294967296", -1, -1, -1, 0, _ef, 10, 0, -1, uimax);
TEST_INT ("9999999999", -1, -1, -1, 0, _ef, 10, 0, -1, uimax);
#elif 8 == _RWSTD_UINT_SIZE
const unsigned uimax = 9223372036854775807U;
TEST_INT ("9223372036854775807", -1, -1, -1, 0, _e_, 10, 0, -1, uimax);
TEST_INT ("9223372036854775808", -1, -1, -1, 0, _ef, 10, 0, -1, uimax);
TEST_INT ("9999999999999999999", -1, -1, -1, 0, _ef, 10, 0, -1, uimax);
#endif // _RWSTD_UINT_SIZE
}
int
main()
{
TEST_INT(0, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(1, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(2, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(3, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(4, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(5, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(6, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(7, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(8, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(9, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(11, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(99, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(111, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(999, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(1111, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(9999, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(1234567890, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(UINT32_MAX, mm_scan_u32, uint32_t, PRIu32);
TEST_INT(UINT32_MAX, mm_scan_u64, uint64_t, PRIu64);
TEST_INT(UINT64_MAX, mm_scan_u64, uint64_t, PRIu64);
TEST_HEX(0X0, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x0, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x1, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x2, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x3, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x4, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x5, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x6, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x7, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x8, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x9, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xA, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xB, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xC, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xD, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xE, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xF, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xa, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xb, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xc, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xd, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xe, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xf, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x12345678, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x9abcdef0, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0xffffffff, mm_scan_x32, uint32_t, PRIx32);
TEST_HEX(0x0123456789abcdef, mm_scan_x64, uint64_t, PRIx64);
TEST_HEX(0xffffffffffffffff, mm_scan_x64, uint64_t, PRIx64);
TEST_INT(0, mm_scan_n32, uint32_t, PRIu32);
TEST_INT(1, mm_scan_n32, uint32_t, PRIu32);
TEST_INT(UINT32_MAX, mm_scan_n32, uint32_t, PRIu32);
TEST_INT(0x0, mm_scan_n32, uint32_t, PRIx32);
TEST_INT(0x1, mm_scan_n32, uint32_t, PRIx32);
TEST_INT(0xffffffff, mm_scan_n32, uint32_t, PRIx32);
TEST_INT(0, mm_scan_d32, int32_t, PRId32);
TEST_INT(1, mm_scan_d32, int32_t, PRId32);
TEST_INT(-1, mm_scan_d32, int32_t, PRId32);
TEST_INT(+1, mm_scan_d32, int32_t, PRId32);
TEST_INT(INT32_MAX, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("+2147483647", 2147483647, 0, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("-2147483648", -2147483648, 0, mm_scan_d32, int32_t, PRId32);
TEST_INT(0, mm_scan_i32, int32_t, PRId32);
TEST_INT(1, mm_scan_i32, int32_t, PRId32);
TEST_INT(-1, mm_scan_i32, int32_t, PRId32);
TEST_INT(+1, mm_scan_i32, int32_t, PRId32);
TEST_INT(INT32_MAX, mm_scan_i32, int32_t, PRId32);
TEST_INT_EXT("+2147483647", 2147483647, 0, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("-2147483648", -2147483648, 0, mm_scan_i32, int32_t, PRId32);
TEST_INT(0x0, mm_scan_i32, int32_t, PRIx32);
TEST_INT(0x1, mm_scan_i32, int32_t, PRIx32);
TEST_INT(0x7fffffff, mm_scan_i32, int32_t, PRIx32);
TEST_INT(0xffffffff, mm_scan_i32, int32_t, PRIx32);
TEST_INT_EXT("100000000", UINT32_MAX, ERANGE, mm_scan_x32, uint32_t, PRIx32);
TEST_INT_EXT("123456780", UINT32_MAX, ERANGE, mm_scan_x32, uint32_t, PRIx32);
TEST_INT_EXT("fffffffff", UINT32_MAX, ERANGE, mm_scan_x32, uint32_t, PRIx32);
TEST_INT_EXT("4294967296", UINT32_MAX, ERANGE, mm_scan_u32, uint32_t, PRIu32);
TEST_INT_EXT("4294967296", UINT32_MAX, ERANGE, mm_scan_n32, uint32_t, PRIu32);
TEST_INT_EXT("5000000000", UINT32_MAX, ERANGE, mm_scan_u32, uint32_t, PRIu32);
TEST_INT_EXT("5000000000", UINT32_MAX, ERANGE, mm_scan_n32, uint32_t, PRIu32);
TEST_INT_EXT("0x100000000", UINT32_MAX, ERANGE, mm_scan_n32, uint32_t, PRIx32);
TEST_INT_EXT("2147483648", INT32_MAX, ERANGE, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("2147483648", INT32_MAX, ERANGE, mm_scan_i32, int32_t, PRId32);
TEST_INT_EXT("-2147483649", INT32_MIN, ERANGE, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("-2147483649", INT32_MIN, ERANGE, mm_scan_i32, int32_t, PRId32);
TEST_INT_EXT("z", 0, EINVAL, mm_scan_u32, uint32_t, PRId32);
TEST_INT_EXT("-", 0, EINVAL, mm_scan_u32, uint32_t, PRId32);
TEST_INT_EXT("+", 0, EINVAL, mm_scan_u32, uint32_t, PRId32);
TEST_INT_EXT("z", 0, EINVAL, mm_scan_x32, uint32_t, PRId32);
TEST_INT_EXT("-", 0, EINVAL, mm_scan_x32, uint32_t, PRId32);
TEST_INT_EXT("+", 0, EINVAL, mm_scan_x32, uint32_t, PRId32);
TEST_INT_EXT("z", 0, EINVAL, mm_scan_n32, uint32_t, PRId32);
TEST_INT_EXT("-", 0, EINVAL, mm_scan_n32, uint32_t, PRId32);
TEST_INT_EXT("+", 0, EINVAL, mm_scan_n32, uint32_t, PRId32);
TEST_INT_EXT("z", 0, EINVAL, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("-", 0, EINVAL, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("+", 0, EINVAL, mm_scan_d32, int32_t, PRId32);
TEST_INT_EXT("z", 0, EINVAL, mm_scan_i32, int32_t, PRId32);
TEST_INT_EXT("-", 0, EINVAL, mm_scan_i32, int32_t, PRId32);
TEST_INT_EXT("+", 0, EINVAL, mm_scan_i32, int32_t, PRId32);
TEST_INT_END("123abc", 123, 0, mm_scan_u32, uint32_t, PRId32, "abc");
TEST_INT_END("123xyz", 123, 0, mm_scan_u32, uint32_t, PRId32, "xyz");
TEST_INT_END("123xyz", 0x123, 0, mm_scan_x32, uint32_t, PRIx32, "xyz");
TEST_INT_END("0x123xyz", 0x123, 0, mm_scan_n32, uint32_t, PRIx32, "xyz");
TEST_INT_END("123abc", 123, 0, mm_scan_d32, int32_t, PRId32, "abc");
TEST_INT_END("123xyz", 123, 0, mm_scan_d32, int32_t, PRId32, "xyz");
TEST_INT_END("-123xyz", -123, 0, mm_scan_d32, int32_t, PRId32, "xyz");
TEST_INT_END("123xyz", 123, 0, mm_scan_i32, int32_t, PRId32, "xyz");
TEST_INT_END("-123xyz", -123, 0, mm_scan_i32, int32_t, PRId32, "xyz");
TEST_INT_END("0x123xyz", 0x123, 0, mm_scan_i32, int32_t, PRIx32, "xyz");
TEST_INT_END("0x", 0, 0, mm_scan_n32, uint32_t, PRIx32, "x");
TEST_INT_END("0xy", 0, 0, mm_scan_n32, uint32_t, PRIx32, "xy");
TEST_INT_END("0x", 0, 0, mm_scan_i32, int32_t, PRIx32, "x");
TEST_INT_END("0xy", 0, 0, mm_scan_i32, int32_t, PRIx32, "xy");
return fail ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
List list;
Data *data[6];
int i, errors = 0;
for (i = 0; i < 6; i++) {
data[i] = calloc(1, sizeof(Data));
}
listInitialize(&list);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
listAppendTail(&list, data[0]);
listAppendTail(&list, data[1]);
listAppendTail(&list, data[2]);
listAppendTail(&list, data[3]);
TEST_INT(listLength(&list), 4);
TEST_INT(listIsEmpty(&list), FALSE);
TEST_PTR(listHead(&list), data[0]);
TEST_PTR(listTail(&list), data[3]);
TEST_PTR(listNext(data[0]), data[1]);
TEST_PTR(listNext(data[1]), data[2]);
TEST_PTR(listNext(data[2]), data[3]);
TEST_PTR(listNext(data[3]), NULL);
TEST_PTR(listPrev(data[3]), data[2]);
TEST_PTR(listPrev(data[2]), data[1]);
TEST_PTR(listPrev(data[1]), data[0]);
TEST_PTR(listPrev(data[0]), NULL);
TEST_PTR(listContaining(data[0]), &list);
TEST_PTR(listContaining(data[1]), &list);
TEST_PTR(listContaining(data[2]), &list);
TEST_PTR(listContaining(data[3]), &list);
listRemove(&list, data[0]);
listRemove(&list, data[1]);
listRemove(&list, data[2]);
listRemove(&list, data[3]);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
TEST_PTR(listContaining(data[0]), NULL);
TEST_PTR(listContaining(data[1]), NULL);
TEST_PTR(listContaining(data[2]), NULL);
TEST_PTR(listContaining(data[3]), NULL);
listInsertHead(&list, data[3]);
listInsertHead(&list, data[2]);
listInsertHead(&list, data[1]);
listInsertHead(&list, data[0]);
TEST_INT(listLength(&list), 4);
TEST_INT(listIsEmpty(&list), FALSE);
TEST_PTR(listHead(&list), data[0]);
TEST_PTR(listTail(&list), data[3]);
TEST_PTR(listNext(data[0]), data[1]);
TEST_PTR(listNext(data[1]), data[2]);
TEST_PTR(listNext(data[2]), data[3]);
TEST_PTR(listNext(data[3]), NULL);
TEST_PTR(listPrev(data[3]), data[2]);
TEST_PTR(listPrev(data[2]), data[1]);
TEST_PTR(listPrev(data[1]), data[0]);
TEST_PTR(listPrev(data[0]), NULL);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveTail(&list), data[3]);
TEST_PTR(listRemoveTail(&list), data[2]);
TEST_INT(listLength(&list), 0);
TEST_INT(listIsEmpty(&list), TRUE);
listAppendTail(&list, data[0]);
listAppendTail(&list, data[3]);
listAppend(&list, data[1], data[0]);
listInsert(&list, data[2], data[3]);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveTail(&list), data[3]);
TEST_PTR(listRemoveTail(&list), data[2]);
data[0]->i = 3;
data[1]->i = 4;
data[2]->i = 5;
data[3]->i = 1;
data[4]->i = 2;
data[5]->i = 3;
listAppendTail(&list, data[0]);
listAppendTail(&list, data[1]);
listAppendTail(&list, data[2]);
listAppendTail(&list, data[3]);
listAppendTail(&list, data[4]);
listAppendTail(&list, data[5]);
listSort(&list, cmp);
TEST_PTR(listRemoveHead(&list), data[3]);
TEST_PTR(listRemoveHead(&list), data[4]);
TEST_PTR(listRemoveHead(&list), data[0]);
TEST_PTR(listRemoveHead(&list), data[5]);
TEST_PTR(listRemoveHead(&list), data[1]);
TEST_PTR(listRemoveHead(&list), data[2]);
exit(errors);
}
int SpTask_Template(void)
{
int sts = 0;
#ifdef HAVE_MPI
//debug
printf("proc %d/%d: check!\n", (int)Sp_MPIRANK, (int)Sp_MPISIZE);
#endif
Mem_BZERO(&glb);
#define TEST_SIZT(name)\
if(!(sts = SpPy_GetInput_sizt(name, &glb.sizt))) {\
printf("%s=%g\n", name, (double)glb.sizt);\
}
#define TEST_INT(name)\
if(!(sts = SpPy_GetInput_int(name, &glb.intgr))) {\
printf("%s=%g\n", name, (double)glb.intgr);\
}
#define TEST_DBL(name)\
if(!(sts = SpPy_GetInput_dbl(name, &glb.dbl))) {\
printf("%s=%g\n", name, (double)glb.dbl);\
}
TEST_INT("int");
TEST_SIZT("pos_int");
TEST_DBL("angle");
TEST_DBL("velo");
TEST_DBL("length");
PyErr_Clear();
sts = 0;
/* This is for checking whether the KeyboardInterrupt exception can
* be caught and propagated to the top-level interpreter */
printf("Send ctrl-c to continue...\n");
while(1) {
if(PyErr_CheckSignals()) {
printf("Signal caught in PyErr_CheckSignals()!\n");
break;
}
sleep(1);
}
PyErr_Clear();
sts = 0;
/* This is to test whether threads can be safely terminated by ctrl-c
* and propagated to the top-level interpreter.
* Threads in Python are a bit tricky to use, since CPython implements
* the "GIL" or "Global Interpreter Lock" which restricts execution
* of the Python VM to a single instruction at a time. Hence if cpu-intensive
* operations are to be done within a C extension module, the GIL needs to be
* released (using Py_BEGIN_ALLOW_THREADS) so that the top-level interpreter
* can tend to other tasks while the (possibly threaded) C code operates.
* Once the C code has completed its task, reacquire the GIL
* (using Py_END_ALLOW_THREADS) so the rest of the operation can be managed
* by the interpreter.
*
* Caveat: the top-level interpreter is no longer in charge of the
* activities of code following the release of the GIL, so signals
* and such must be managed explicitly!
*/
if(!sts) sts = SpUtil_Threads2(2, ExecThread);
return sts;
}
void
test_int (CharT*, Traits*,
const char *cname,
const char *tname)
{
info (cname, tname, "int");
test_extractor ((CharT*)0, (Traits*)0, (int*)0,
cname, tname, "int", "%i");
#define TEST_INT(ss, fl, is, ex, ee, es, ne, fw, iv, ev) \
TEST (int, "%i", ss, fl, is, ex, ee, es, ne, fw, iv, ev)
LocaleData locale_data = { 0, -1, -1, 0, 0, 0 };
locale_data.whitespace = "";
#if 2 == _RWSTD_INT_SIZE
const int imax = +32767;
const int imin = -imax - 1;
TEST_INT ("-32768", -1, -1, -1, 0, _e_, 6, 0, 1, imin);
TEST_INT ("-32769", -1, -1, -1, 0, _ef, 6, 0, 1, imin);
TEST_INT ("-99999", -1, -1, -1, 0, _ef, 6, 0, 1, imin);
TEST_INT ("+32767", -1, -1, -1, 0, _e_, 6, 0, 1, imax);
TEST_INT ("+32768", -1, -1, -1, 0, _ef, 6, 0, 1, imax);
TEST_INT ("+99999", -1, -1, -1, 0, _ef, 6, 0, 1, imax);
#elif 4 == _RWSTD_INT_SIZE
const int imax = +2147483647;
const int imin = -imax - 1;
TEST_INT ("-2147483648", -1, -1, -1, 0, _e_, 11, 0, -1, imin);
TEST_INT ("-2147483649", -1, -1, -1, 0, _ef, 11, 0, -1, imin);
TEST_INT ("-9999999999", -1, -1, -1, 0, _ef, 11, 0, -1, imin);
TEST_INT ("+2147483647", -1, -1, -1, 0, _e_, 11, 0, -1, imax);
TEST_INT ("+2147483648", -1, -1, -1, 0, _ef, 11, 0, -1, imax);
TEST_INT ("99999999999", -1, -1, -1, 0, _ef, 11, 0, -1, imax);
#elif 8 == _RWSTD_INT_SIZE
const int imax = +9223372036854775807;
const int imin = -imax - 1;
TEST_INT ("-9223372036854775808", -1, -1, -1, 0, _e_, 20, 0, -1, imin);
TEST_INT ("-9223372036854775809", -1, -1, -1, 0, _ef, 20, 0, -1, imin);
TEST_INT ("-9999999999999999999", -1, -1, -1, 0, _ef, 20, 0, -1, imin);
TEST_INT ("+9223372036854775807", -1, -1, -1, 0, _e_, 20, 0, -1, imax);
TEST_INT ("+9223372036854775808", -1, -1, -1, 0, _ef, 20, 0, -1, imax);
TEST_INT ("99999999999999999999", -1, -1, -1, 0, _ef, 20, 0, -1, imax);
#endif // _RWSTD_INT_SIZE
}
