static void validateDatetimeType(xmlrpc_env *const envP, const xmlrpc_value *const valueP) { if (valueP->_type != XMLRPC_TYPE_DATETIME) { xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value of type %s supplied where " "type %s was expected.", xmlrpc_type_name(valueP->_type), xmlrpc_type_name(XMLRPC_TYPE_DATETIME)); } }
static void test_value_double(void) { xmlrpc_value * v; xmlrpc_env env; double d; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_DOUBLE), "DOUBLE")); v = xmlrpc_double_new(&env, -3.25); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_DOUBLE == xmlrpc_value_type(v)); xmlrpc_read_double(&env, v, &d); TEST_NO_FAULT(&env); TEST(d == -3.25); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "d", 1.0); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(XMLRPC_TYPE_DOUBLE == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "d", &d); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(d == 1.0); xmlrpc_env_clean(&env); }
static void test_value_bool(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_bool b; /* Test booleans. */ xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BOOL), "BOOL")); v = xmlrpc_bool_new(&env, (xmlrpc_bool) 1); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v)); xmlrpc_read_bool(&env, v, &b); TEST_NO_FAULT(&env); TEST(b); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "b", (xmlrpc_bool) 0); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(XMLRPC_TYPE_BOOL == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "b", &b); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(!b); xmlrpc_env_clean(&env); }
static void validateStringType(xmlrpc_env * const envP, const xmlrpc_value * const valueP) { if (valueP->_type != XMLRPC_TYPE_STRING) { xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value of type %s supplied where " "string type was expected.", xmlrpc_type_name(valueP->_type)); } }
static void test_value_i8(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_int64 i; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_I8), "I8")); v = xmlrpc_i8_new(&env, (xmlrpc_int64) 25); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8); xmlrpc_read_i8(&env, v, &i); TEST_NO_FAULT(&env); TEST(i == 25); xmlrpc_DECREF(v); v = xmlrpc_i8_new(&env, (xmlrpc_int64) -25); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8); xmlrpc_read_i8(&env, v, &i); TEST_NO_FAULT(&env); TEST(i == -25); xmlrpc_DECREF(v); v = xmlrpc_i8_new(&env, (xmlrpc_int64)1 << 40); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8); xmlrpc_read_i8(&env, v, &i); TEST_NO_FAULT(&env); TEST(i == (xmlrpc_int64)1 << 40); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "I", (xmlrpc_int64) 10); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_I8); xmlrpc_decompose_value(&env, v, "I", &i); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(i == 10); xmlrpc_env_clean(&env); }
static void test_value_array(void) { xmlrpc_value *v; xmlrpc_env env; size_t len; xmlrpc_value * itemP; /* Basic array-building test. */ xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_ARRAY), "ARRAY")); v = xmlrpc_array_new(&env); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v)); len = xmlrpc_array_size(&env, v); TEST_NO_FAULT(&env); TEST(len == 0); itemP = xmlrpc_int_new(&env, 7); TEST_NO_FAULT(&env); xmlrpc_array_append_item(&env, v, itemP); TEST_NO_FAULT(&env); len = xmlrpc_array_size(&env, v); TEST_NO_FAULT(&env); TEST(len == 1); xmlrpc_DECREF(itemP); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "()"); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v)); len = xmlrpc_array_size(&env, v); TEST_NO_FAULT(&env); TEST(len == 0); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
static void test_value_base64(void) { /* Test <base64> data. */ unsigned char const data1[5] = {'a', '\0', 'b', '\n', 'c'}; unsigned char const data2[3] = {'a', '\0', 'b'}; xmlrpc_value * v; xmlrpc_env env; const unsigned char * data; size_t len; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_BASE64), "BASE64")); v = xmlrpc_base64_new(&env, sizeof(data1), data1); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_BASE64 == xmlrpc_value_type(v)); xmlrpc_read_base64(&env, v, &len, &data); TEST_NO_FAULT(&env); TEST(memeq(data, data1, sizeof(data1))); TEST(len == sizeof(data1)); xmlrpc_DECREF(v); free((void*)data); v = xmlrpc_build_value(&env, "6", data2, sizeof(data2)); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_BASE64 == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "6", &data, &len); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(len == sizeof(data2)); TEST(memeq(data, data1, sizeof(data2))); free((void *)data); xmlrpc_env_clean(&env); }
static void test_value_cptr(void) { int destroyConfirmation; xmlrpc_value * v; xmlrpc_env env; void * ptr; int myObject; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_C_PTR), "C_PTR")); myObject = 7; v = xmlrpc_cptr_new(&env, &myObject); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_C_PTR); xmlrpc_DECREF(v); v = xmlrpc_cptr_new_dtor(&env, &myObject, &destroyMyCptr, &destroyConfirmation); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_C_PTR); destroyConfirmation = 3; xmlrpc_DECREF(v); TEST(destroyConfirmation == 7); // the destructor has set this v = xmlrpc_build_value(&env, "p", (void*) 0x00000017); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_C_PTR == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "p", &ptr); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(ptr == (void*) 0x00000017); xmlrpc_env_clean(&env); }
static void test_value_int(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_int32 i; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_INT), "INT")); v = xmlrpc_int_new(&env, (xmlrpc_int32) 25); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_INT); xmlrpc_read_int(&env, v, &i); TEST_NO_FAULT(&env); TEST(i == 25); xmlrpc_DECREF(v); v = xmlrpc_int_new(&env, (xmlrpc_int32) -25); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_INT); xmlrpc_read_int(&env, v, &i); TEST_NO_FAULT(&env); TEST(i == -25); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "i", (xmlrpc_int32) 10); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_INT); xmlrpc_decompose_value(&env, v, "i", &i); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(i == 10); xmlrpc_env_clean(&env); }
static void test_value_nil(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_NIL), "NIL")); v = xmlrpc_nil_new(&env); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_NIL); xmlrpc_DECREF(v); v = xmlrpc_build_value(&env, "n"); TEST_NO_FAULT(&env); TEST(XMLRPC_TYPE_NIL == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "n"); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); xmlrpc_env_clean(&env); }
void test_value_datetime(void) { const char * datestring = "19980717T14:08:55"; time_t const datetime = 900684535; xmlrpc_env env; printf("\n Running datetime value tests"); xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_DATETIME), "DATETIME")); test_value_datetime_basic(); /* Valid datetime, generated from XML-RPC string, time_t, and time_t + microseconds */ test_value_datetime_varytime(datestring, datetime, 0); /* test microseconds */ test_value_datetime_varytime("20000301T00:00:00.654321", 951868800, 654321); test_value_datetime_varytime("20040229T23:59:59.123000", 1078099199, 123000); test_value_datetime_varytime("20000229T23:59:59.000123", 951868799, 123); /* Leap years */ test_value_datetime_varytime("20000229T23:59:59", 951868799, 0); test_value_datetime_varytime("20000301T00:00:00", 951868800, 0); test_value_datetime_varytime("20010228T23:59:59", 983404799, 0); test_value_datetime_varytime("20010301T00:00:00", 983404800, 0); test_value_datetime_varytime("20040229T23:59:59", 1078099199, 0); test_value_datetime_varytime("20040301T00:00:00", 1078099200, 0); /* Datetimes that can't be represented as time_t */ test_value_datetime_not_unix("19691231T23:59:59"); /* Invalid datetimes */ /* Note that the code today does a pretty weak job of validating datetimes, so we test only the validation that we know is implemented. */ test_value_datetime_str_invalid1("19700101T25:00:00"); test_value_datetime_str_invalid1("19700101T10:61:01"); test_value_datetime_str_invalid1("19700101T10:59:61"); test_value_datetime_str_invalid1("19700001T10:00:00"); test_value_datetime_str_invalid1("19701301T10:00:00"); test_value_datetime_str_invalid1("19700132T10:00:00"); test_value_datetime_str_invalid2("19700132T10:00:00."); test_value_datetime_str_invalid2("19700132T10:00:00,123"); test_build_decomp_datetime(); xmlrpc_env_clean(&env); printf("\n"); printf(" datetime value tests done.\n"); }
static void decomposeValueWithTree(xmlrpc_env * const envP, xmlrpc_value * const valueP, bool const oldstyleMemMgmt, const struct decompTreeNode * const decompRootP) { /*---------------------------------------------------------------------------- Decompose XML-RPC value *valueP, given the decomposition tree *decompRootP. The decomposition tree tells what structure *valueP is expected to have and where to put the various components of it (e.g. it says "it's an array of 3 integers. Put their values at locations x, y, and z") -----------------------------------------------------------------------------*/ switch (decompRootP->formatSpecChar) { case '-': /* There's nothing to validate or return */ break; case 'i': xmlrpc_read_int(envP, valueP, decompRootP->store.Tinteger.valueP); break; case 'b': xmlrpc_read_bool(envP, valueP, decompRootP->store.Tbool.valueP); break; case 'd': xmlrpc_read_double(envP, valueP, decompRootP->store.Tdouble.valueP); break; case 't': xmlrpc_read_datetime_sec(envP, valueP, decompRootP->store.TdatetimeT.valueP); break; case '8': readDatetime8Str(envP, valueP, decompRootP->store.Tdatetime8.valueP, oldstyleMemMgmt); break; case 's': if (decompRootP->store.Tstring.sizeP) readStringLp(envP, valueP, decompRootP->store.Tstring.sizeP, decompRootP->store.Tstring.valueP, oldstyleMemMgmt); else readString(envP, valueP, decompRootP->store.Tstring.valueP, oldstyleMemMgmt); break; case 'w': #if HAVE_UNICODE_WCHAR if (decompRootP->store.Tstring.sizeP) readStringWLp(envP, valueP, decompRootP->store.TwideString.sizeP, decompRootP->store.TwideString.valueP, oldstyleMemMgmt); else readStringW(envP, valueP, decompRootP->store.TwideString.valueP, oldstyleMemMgmt); #else XMLRPC_ASSERT(false); #endif /* HAVE_UNICODE_WCHAR */ break; case '6': readBase64(envP, valueP, decompRootP->store.TbitString.sizeP, decompRootP->store.TbitString.valueP, oldstyleMemMgmt); break; case 'n': xmlrpc_read_nil(envP, valueP); break; case 'I': xmlrpc_read_i8(envP, valueP, decompRootP->store.Ti8.valueP); break; case 'p': xmlrpc_read_cptr(envP, valueP, decompRootP->store.Tcptr.valueP); break; case 'V': *decompRootP->store.Tvalue.valueP = valueP; if (!oldstyleMemMgmt) xmlrpc_INCREF(valueP); break; case 'A': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the 'A' specifier requires type ARRAY", xmlrpc_type_name(xmlrpc_value_type(valueP))); else { *decompRootP->store.TarrayVal.valueP = valueP; if (!oldstyleMemMgmt) xmlrpc_INCREF(valueP); } break; case 'S': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the 'S' specifier requires type STRUCT.", xmlrpc_type_name(xmlrpc_value_type(valueP))); else { *decompRootP->store.TstructVal.valueP = valueP; if (!oldstyleMemMgmt) xmlrpc_INCREF(valueP); } break; case '(': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_ARRAY) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the '(...)' specifier requires type ARRAY", xmlrpc_type_name(xmlrpc_value_type(valueP))); else parsearray(envP, valueP, decompRootP->store.Tarray, oldstyleMemMgmt); break; case '{': if (xmlrpc_value_type(valueP) != XMLRPC_TYPE_STRUCT) xmlrpc_env_set_fault_formatted( envP, XMLRPC_TYPE_ERROR, "Value to be decomposed is of type " "%s, but the '{...}' specifier requires type STRUCT", xmlrpc_type_name(xmlrpc_value_type(valueP))); else parsestruct(envP, valueP, decompRootP->store.Tstruct, oldstyleMemMgmt); break; default: /* Every format character that is allowed in a decomposition tree node is handled above. */ XMLRPC_ASSERT(false); } }
static void test_value_string_no_null(void) { /* Test strings (without '\0' bytes). */ xmlrpc_value * v; xmlrpc_env env; const char * str; size_t len; xmlrpc_env_init(&env); TEST(streq(xmlrpc_type_name(XMLRPC_TYPE_STRING), "STRING")); { const char * const simpleAsciiString = "foo"; v = xmlrpc_string_new(&env, simpleAsciiString); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, simpleAsciiString)); xmlrpc_DECREF(v); strfree(str); } { const char * const utf8String = "KOŚĆ"; v = xmlrpc_string_new(&env, utf8String); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, utf8String)); xmlrpc_DECREF(v); strfree(str); } v = xmlrpc_string_new_f(&env, "String %s, number %d", "xyz", 7); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "String xyz, number 7")); xmlrpc_DECREF(v); strfree(str); v = test_string_new_va(&env, "String %s, number %d", "xyz", 7); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_STRING); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "String xyz, number 7")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_build_value(&env, "s", "foo"); TEST_NO_FAULT(&env); TEST(v != NULL); TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v)); xmlrpc_decompose_value(&env, v, "s", &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo")); strfree(str); xmlrpc_decompose_value(&env, v, "s#", &str, &len); TEST_NO_FAULT(&env); TEST(len == strlen("foo")); TEST(xmlrpc_streq(str, "foo")); TEST(strlen(str) == strlen("foo")); strfree(str); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
ostream &operator<<(ostream &out, value::type_t const &type) { string typeName; return out << string(xmlrpc_type_name((xmlrpc_type) type)); }