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));
}
