static void
test_value_AS(void) {
xmlrpc_value *v;
xmlrpc_value *v2;
xmlrpc_value *v3;
xmlrpc_env env;
size_t len;
/* Test parsing of 'A' and 'S'. */
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "((){})");
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, v, "(AS)", &v2, &v3);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(v2));
TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(v3));
len = xmlrpc_array_size(&env, v2);
TEST_NO_FAULT(&env);
TEST(len == 0);
len = xmlrpc_struct_size(&env, v3);
TEST_NO_FAULT(&env);
TEST(len == 0);
xmlrpc_DECREF(v2);
xmlrpc_DECREF(v3);
xmlrpc_env_clean(&env);
}
static void
getMethListFromMulticallPlist(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
xmlrpc_value ** const methlistPP) {
if (xmlrpc_array_size(envP, paramArrayP) != 1)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_PARSE_ERROR,
"system.multicall takes one parameter, which is an "
"array, each element describing one RPC. You "
"supplied %u arguments",
xmlrpc_array_size(envP, paramArrayP));
else {
xmlrpc_value * methlistP;
xmlrpc_array_read_item(envP, paramArrayP, 0, &methlistP);
XMLRPC_ASSERT_ENV_OK(envP);
if (xmlrpc_value_type(methlistP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR,
"system.multicall's parameter should be an array, "
"each element describing one RPC. But it is type "
"%u instead.", xmlrpc_value_type(methlistP));
else
*methlistPP = methlistP;
if (envP->fault_occurred)
xmlrpc_DECREF(methlistP);
}
}
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
test_value_array(void) {
xmlrpc_value *v;
xmlrpc_env env;
size_t len;
/* Basic array-building test. */
xmlrpc_env_init(&env);
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);
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_integer(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_int32 i;
xmlrpc_env_init(&env);
v = xmlrpc_int_new(&env, (xmlrpc_int32) 25);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_INT == xmlrpc_value_type(v));
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_TYPE_INT == xmlrpc_value_type(v));
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_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_parse_value(void) {
xmlrpc_env env;
xmlrpc_value * valueP;
const char * datestring = "19980717T14:08:55";
xmlrpc_env_init(&env);
valueP = xmlrpc_build_value(&env, "(idb8ss#6(i){s:i}np(i))",
7, 3.14, (xmlrpc_bool)1, datestring,
"hello world", "a\0b", (size_t)3,
"base64 data", strlen("base64 data"),
15, "member9", 9, &valueP, -5);
TEST_NO_FAULT(&env);
{
xmlrpc_int32 i;
xmlrpc_double d;
xmlrpc_bool b;
const char * dt_str;
const char * s1;
const char * s2;
size_t s2_len;
const unsigned char * b64;
size_t b64_len;
xmlrpc_value * arrayP;
xmlrpc_value * structP;
void * cptr;
xmlrpc_value * subvalP;
xmlrpc_parse_value(&env, valueP, "(idb8ss#6ASnpV)",
&i, &d, &b, &dt_str, &s1, &s2, &s2_len,
&b64, &b64_len,
&arrayP, &structP, &cptr, &subvalP);
TEST_NO_FAULT(&env);
TEST(i == 7);
TEST(d == 3.14);
TEST(b == (xmlrpc_bool)1);
TEST(streq(dt_str, datestring));
TEST(streq(s1, "hello world"));
TEST(s2_len == 3);
TEST(memeq(s2, "a\0b", 3));
TEST(b64_len == strlen("base64 data"));
TEST(memeq(b64, "base64 data", b64_len));
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));
TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(structP));
TEST(cptr == &valueP);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(subvalP));
xmlrpc_DECREF(valueP);
}
testFailedParseValue();
xmlrpc_env_clean(&env);
}
static void
callOneMethod(xmlrpc_env * const envP,
xmlrpc_registry * const registryP,
xmlrpc_value * const rpcDescP,
void * const callInfo,
xmlrpc_value ** const resultPP) {
const char * methodName;
xmlrpc_value * paramArrayP;
XMLRPC_ASSERT_ENV_OK(envP);
if (xmlrpc_value_type(rpcDescP) != XMLRPC_TYPE_STRUCT)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR,
"An element of the multicall array is type %u, but should "
"be a struct (with members 'methodName' and 'params')",
xmlrpc_value_type(rpcDescP));
else {
xmlrpc_decompose_value(envP, rpcDescP, "{s:s,s:A,*}",
"methodName", &methodName,
"params", ¶mArrayP);
if (!envP->fault_occurred) {
/* Watch out for a deep recursion attack. */
if (xmlrpc_streq(methodName, "system.multicall"))
xmlrpc_env_set_fault_formatted(
envP,
XMLRPC_REQUEST_REFUSED_ERROR,
"Recursive system.multicall forbidden");
else {
xmlrpc_env env;
xmlrpc_value * resultValP;
xmlrpc_env_init(&env);
xmlrpc_dispatchCall(&env, registryP, methodName, paramArrayP,
callInfo,
&resultValP);
if (env.fault_occurred) {
/* Method failed, so result is a fault structure */
*resultPP =
xmlrpc_build_value(
envP, "{s:i,s:s}",
"faultCode", (xmlrpc_int32) env.fault_code,
"faultString", env.fault_string);
} else {
*resultPP = xmlrpc_build_value(envP, "(V)", resultValP);
xmlrpc_DECREF(resultValP);
}
xmlrpc_env_clean(&env);
}
xmlrpc_DECREF(paramArrayP);
xmlrpc_strfree(methodName);
}
}
}
static void
test_value_datetime(void) {
const char * datestring = "19980717T14:08:55";
time_t const datetime = 900684535;
xmlrpc_value * v;
xmlrpc_env env;
const char * ds;
time_t dt;
xmlrpc_env_init(&env);
v = xmlrpc_datetime_new_str(&env, datestring);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &ds);
TEST_NO_FAULT(&env);
TEST(strcmp(ds, datestring) == 0);
strfree(ds);
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST_NO_FAULT(&env);
TEST(dt == datetime);
xmlrpc_DECREF(v);
v = xmlrpc_datetime_new_sec(&env, datetime);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &ds);
TEST_NO_FAULT(&env);
TEST(strcmp(ds, datestring) == 0);
strfree(ds);
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST_NO_FAULT(&env);
TEST(dt == datetime);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "8", datestring);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "8", &ds);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(strcmp(ds, datestring) == 0);
strfree(ds);
xmlrpc_env_clean(&env);
}
static void
test_build_decomp_datetime(void) {
const char * datestring = "19980717T14:08:55";
time_t const datetime = 900684535;
xmlrpc_env env;
xmlrpc_value * v;
time_t dt;
const char * ds;
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "t", datetime);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);
dt = 0;
xmlrpc_read_datetime_sec(&env, v, &dt);
TEST(dt == datetime);
dt = 0;
xmlrpc_decompose_value(&env, v, "t", &dt);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(dt == datetime);
v = xmlrpc_int_new(&env, 9);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, v, "t", &dt);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_decompose_value(&env, v, "8", &ds);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_DECREF(v);
v = xmlrpc_build_value(&env, "8", datestring);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(xmlrpc_value_type(v) == XMLRPC_TYPE_DATETIME);
xmlrpc_decompose_value(&env, v, "8", &ds);
xmlrpc_DECREF(v);
TEST_NO_FAULT(&env);
TEST(streq(ds, datestring));
strfree(ds);
xmlrpc_env_clean(&env);
}
static void get_int64(xmlrpc_value *value, int64_t *num) {
xmlrpc_int64 tmp;
assert(xmlrpc_value_type(value) == XMLRPC_TYPE_I8);
xmlrpc_read_i8(&env, value, &tmp);
check_fault();
*num = (int64_t) tmp;
}
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_string_null(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_env env2;
const char * str;
size_t len;
/* Test a string with a '\0' byte. */
xmlrpc_env_init(&env);
v = xmlrpc_string_new_lp(&env, 7, "foo\0bar");
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_read_string_lp(&env, v, &len, &str);
TEST_NO_FAULT(&env);
TEST(len == 7);
TEST(memeq(str, "foo\0bar", 7));
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_build_value(&env, "s#", "foo\0bar", (size_t) 7);
TEST_NO_FAULT(&env);
TEST(v != NULL);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_decompose_value(&env, v, "s#", &str, &len);
TEST_NO_FAULT(&env);
TEST(memeq(str, "foo\0bar", 7));
TEST(len == 7);
strfree(str);
/* Test for type error when decoding a string with a zero byte to a
** regular C string. */
xmlrpc_env_init(&env2);
xmlrpc_decompose_value(&env2, v, "s", &str);
TEST_FAULT(&env2, XMLRPC_TYPE_ERROR);
xmlrpc_env_clean(&env2);
xmlrpc_DECREF(v);
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_string_no_null(void) {
xmlrpc_value * v;
xmlrpc_env env;
const char * str;
size_t len;
/* Test strings (without '\0' bytes). */
xmlrpc_env_init(&env);
v = xmlrpc_string_new(&env, test_string_1);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_STRING == xmlrpc_value_type(v));
xmlrpc_read_string(&env, v, &str);
TEST_NO_FAULT(&env);
TEST(strcmp(str, test_string_1) == 0);
xmlrpc_DECREF(v);
strfree(str);
v = xmlrpc_build_value(&env, "s", test_string_1);
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(strcmp(str, test_string_1) == 0);
strfree(str);
xmlrpc_decompose_value(&env, v, "s#", &str, &len);
TEST_NO_FAULT(&env);
TEST(memcmp(str, test_string_1, strlen(test_string_1)) == 0);
TEST(strlen(str) == strlen(test_string_1));
strfree(str);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
/*
* Make an XML-RPC call to methodName. This uses the curl client to make
* a connection over SSL using the CA cert that should have been installed
* by ipa-client-install.
*/
static void
callRPC(char * user_agent,
xmlrpc_env * const envP,
xmlrpc_server_info * const serverInfoP,
const char * const methodName,
xmlrpc_value * const paramArrayP,
xmlrpc_value ** const resultPP) {
struct xmlrpc_clientparms clientparms;
struct xmlrpc_curl_xportparms * curlXportParmsP = NULL;
xmlrpc_client * clientP = NULL;
memset(&clientparms, 0, sizeof(clientparms));
XMLRPC_ASSERT(xmlrpc_value_type(paramArrayP) == XMLRPC_TYPE_ARRAY);
curlXportParmsP = malloc(sizeof(*curlXportParmsP));
if (curlXportParmsP == NULL) {
xmlrpc_env_set_fault(envP, XMLRPC_INTERNAL_ERROR, _("Out of memory!"));
return;
}
memset(curlXportParmsP, 0, sizeof(*curlXportParmsP));
/* Have curl do SSL certificate validation */
curlXportParmsP->no_ssl_verifypeer = 0;
curlXportParmsP->no_ssl_verifyhost = 0;
curlXportParmsP->cainfo = "/etc/ipa/ca.crt";
curlXportParmsP->user_agent = user_agent;
/* Enable GSSAPI credentials delegation */
curlXportParmsP->gssapi_delegation = 1;
clientparms.transport = "curl";
clientparms.transportparmsP = (struct xmlrpc_xportparms *)
curlXportParmsP;
clientparms.transportparm_size = XMLRPC_CXPSIZE(gssapi_delegation);
xmlrpc_client_create(envP, XMLRPC_CLIENT_NO_FLAGS, NAME, VERSION,
&clientparms, sizeof(clientparms),
&clientP);
/* Set up kerberos negotiate authentication in curl. */
xmlrpc_server_info_set_user(envP, serverInfoP, ":", "");
xmlrpc_server_info_allow_auth_negotiate(envP, serverInfoP);
/* Perform the XML-RPC call */
if (!envP->fault_occurred) {
xmlrpc_client_call2(envP, clientP, serverInfoP, methodName, paramArrayP, resultPP);
}
/* Cleanup */
xmlrpc_server_info_free(serverInfoP);
xmlrpc_client_destroy(clientP);
free((void*)clientparms.transportparmsP);
}
static void
test_value_array_nil(void) {
xmlrpc_value * arrayP;
xmlrpc_env env;
xmlrpc_int32 i1, i2;
xmlrpc_value * itemP;
size_t len;
xmlrpc_env_init(&env);
arrayP = xmlrpc_build_value(&env, "(nini)",
(xmlrpc_int32) 10, (xmlrpc_int32) 20);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));
len = xmlrpc_array_size(&env, arrayP);
TEST_NO_FAULT(&env);
TEST(len == 4);
itemP = xmlrpc_array_get_item(&env, arrayP, 0);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "n");
TEST_NO_FAULT(&env);
itemP = xmlrpc_array_get_item(&env, arrayP, 1);
TEST_NO_FAULT(&env);
{
int i;
xmlrpc_decompose_value(&env, itemP, "i", &i);
TEST_NO_FAULT(&env);
TEST(i == 10);
}
xmlrpc_decompose_value(&env, arrayP, "(nini)", &i1, &i2);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20);
/* Test bounds check on xmlrpc_array_get_item. */
xmlrpc_array_read_item(&env, arrayP, 4, &itemP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_array_get_item(&env, arrayP, 4);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_env_clean(&env);
xmlrpc_env_init(&env);
xmlrpc_DECREF(arrayP);
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_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_nil(void) {
xmlrpc_value * v;
xmlrpc_env env;
xmlrpc_env_init(&env);
v = xmlrpc_nil_new(&env);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_NIL == xmlrpc_value_type(v));
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);
}
/* Utility routine to get the value of an array by its index.
*/
static xmlrpc_value *
xr_getArrValue (xmlrpc_value *val, int index)
{
xmlrpc_value *v;
xmlrpc_env env;
if (xmlrpc_value_type (val) == XMLRPC_TYPE_ARRAY) {
xmlrpc_array_read_item (&env, val, index, &v);
return (v);
} else {
xmlrpc_INCREF(val);
return (val);
}
}
value::type_t
value::type() const {
/* You'd think we could just cast from xmlrpc_type to
value:type_t, but Gcc warns if we do that. So we have to do this
even messier union nonsense.
*/
union {
xmlrpc_type x;
value::type_t y;
} u;
u.x = xmlrpc_value_type(this->cValueP);
return u.y;
}
static void
test_value_cptr(void) {
xmlrpc_value * v;
xmlrpc_env env;
void * ptr;
/* Test C pointer storage using 'p'.
We don't have cleanup functions (yet).
*/
xmlrpc_env_init(&env);
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);
}
/* FIXME terminates the programm if it fails */
int get_struct_item_by_idx(xmlrpc_value *structP, int index, key_value_pair *rv)
{
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_value *keyP;
xmlrpc_value *valueP;
int length;
const char *string;
xmlrpc_struct_read_member(&env, structP, index, &keyP, &valueP); /* increment refcount of returned values */
die_if_fault_occurred_line(&env, __LINE__);
xmlrpc_read_string(&env, keyP, (const char **)&rv->key);
/* handle value type */
switch ( xmlrpc_value_type(valueP) ) {
case XMLRPC_TYPE_INT:
xmlrpc_read_int(&env, valueP, &rv->value.integer);
die_if_fault_occurred_line(&env, __LINE__);
rv->type = TYPE_INTEGER;
break;
case XMLRPC_TYPE_STRING:
xmlrpc_read_string(&env, valueP, &string);
printf("get_struct_item_by_idx: ptr = %p, string value = '%s'\n", string, string);
die_if_fault_occurred_line(&env, __LINE__);
rv->value.string = (char *)string;
rv->type = TYPE_STRING;
break;
default:
fprintf(stderr, "Wrong type of return value in key: '%s', exiting...\n", rv->key);
exit(1);
}
xmlrpc_DECREF(keyP); /* decrement refcount */
xmlrpc_DECREF(valueP);
die_if_fault_occurred_line(&env, __LINE__);
/* FIXME add error handling */
return 1;
}
void
xmlrpc_array_append_item(xmlrpc_env * const envP,
xmlrpc_value * const arrayP,
xmlrpc_value * const valueP) {
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_VALUE_OK(arrayP);
if (xmlrpc_value_type(arrayP) != XMLRPC_TYPE_ARRAY)
xmlrpc_env_set_fault_formatted(
envP, XMLRPC_TYPE_ERROR, "Value is not an array");
else {
size_t const size =
XMLRPC_MEMBLOCK_SIZE(xmlrpc_value *, &arrayP->_block);
XMLRPC_MEMBLOCK_RESIZE(xmlrpc_value *, envP, &arrayP->_block, size+1);
if (!envP->fault_occurred) {
xmlrpc_value ** const contents =
XMLRPC_MEMBLOCK_CONTENTS(xmlrpc_value*, &arrayP->_block);
xmlrpc_INCREF(valueP);
contents[size] = valueP;
}
}
static void
test_value_datetime_varytime(const char * const datestring,
time_t const datetime,
unsigned int const usec) {
xmlrpc_value * v;
xmlrpc_env env;
const char * readBackString;
time_t readBackDt;
unsigned int readBackUsec;
const char * datestringSec;
#if XMLRPC_HAVE_TIMEVAL
struct timeval const dtTimeval = makeTv(datetime, usec);
struct timeval readBackTv;
#endif
#if XMLRPC_HAVE_TIMESPEC
struct timespec const dtTimespec = makeTs(datetime, usec);
struct timespec readBackTs;
#endif
const char * const dt8601 = make8601(datetime, usec);
const char * readBack8601;
datestringSec = truncateFracSec(datestring);
xmlrpc_env_init(&env);
/* Test xmlrpc_datetime_new_str and time read functions*/
v = xmlrpc_datetime_new_str(&env, datestring);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_sec(&env, v, &readBackDt);
TEST_NO_FAULT(&env);
TEST(readBackDt == datetime);
xmlrpc_read_datetime_usec(&env, v, &readBackDt, &readBackUsec);
TEST_NO_FAULT(&env);
TEST(readBackDt == datetime);
TEST(readBackUsec == usec);
#if XMLRPC_HAVE_TIMEVAL
xmlrpc_read_datetime_timeval(&env, v, &readBackTv);
TEST_NO_FAULT(&env);
TEST(tvIsEqual(dtTimeval, readBackTv));
#endif
#if XMLRPC_HAVE_TIMESPEC
xmlrpc_read_datetime_timespec(&env, v, &readBackTs);
TEST_NO_FAULT(&env);
TEST(tsIsEqual(dtTimespec, readBackTs));
#endif
xmlrpc_read_datetime_8601(&env, v, &readBack8601);
TEST_NO_FAULT(&env);
TEST(xmlrpc_streq(dt8601, readBack8601));
strfree(readBack8601);
xmlrpc_DECREF(v);
/* Test xmlrpc_datetime_new_sec */
v = xmlrpc_datetime_new_sec(&env, datetime);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestringSec));
strfree(readBackString);
xmlrpc_DECREF(v);
/* Test xmlrpc_datetime_new_usec */
v = xmlrpc_datetime_new_usec(&env, datetime, usec);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestring));
strfree(readBackString);
xmlrpc_DECREF(v);
#if XMLRPC_HAVE_TIMEVAL
/* Test xmlrpc_datetime_new_timeval */
v = xmlrpc_datetime_new_timeval(&env, dtTimeval);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestring));
strfree(readBackString);
xmlrpc_DECREF(v);
#endif
#if XMLRPC_HAVE_TIMESPEC
/* Test xmlrpc_datetime_new_timespec */
v = xmlrpc_datetime_new_timespec(&env, dtTimespec);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_DATETIME == xmlrpc_value_type(v));
xmlrpc_read_datetime_str(&env, v, &readBackString);
TEST_NO_FAULT(&env);
TEST(streq(readBackString, datestring));
strfree(readBackString);
xmlrpc_DECREF(v);
#endif
xmlrpc_env_clean(&env);
strfree(datestringSec);
}
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_array2(void) {
xmlrpc_value * arrayP;
xmlrpc_env env;
xmlrpc_int32 i, i1, i2, i3, i4, i5;
xmlrpc_value * itemP;
xmlrpc_value * subarrayP;
size_t len;
/* A more complex array. */
xmlrpc_env_init(&env);
arrayP = xmlrpc_build_value(&env, "(i(ii)i)",
(xmlrpc_int32) 10, (xmlrpc_int32) 20,
(xmlrpc_int32) 30, (xmlrpc_int32) 40);
TEST_NO_FAULT(&env);
TEST(XMLRPC_TYPE_ARRAY == xmlrpc_value_type(arrayP));
len = xmlrpc_array_size(&env, arrayP);
TEST_NO_FAULT(&env);
TEST(len == 3);
xmlrpc_array_read_item(&env, arrayP, 1, &subarrayP);
TEST_NO_FAULT(&env);
len = xmlrpc_array_size(&env, subarrayP);
TEST_NO_FAULT(&env);
TEST(len == 2);
xmlrpc_array_read_item(&env, subarrayP, 0, &itemP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "i", &i);
xmlrpc_DECREF(itemP);
TEST_NO_FAULT(&env);
TEST(i == 20);
xmlrpc_DECREF(subarrayP);
itemP = xmlrpc_array_get_item(&env, arrayP, 0);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, itemP, "i", &i);
TEST_NO_FAULT(&env);
TEST(i == 10);
xmlrpc_decompose_value(&env, arrayP, "(i(ii)i)", &i1, &i2, &i3, &i4);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20 && i3 == 30 && i4 == 40);
xmlrpc_decompose_value(&env, arrayP, "(i(i*)i)", &i1, &i2, &i3);
TEST_NO_FAULT(&env);
TEST(i1 == 10 && i2 == 20 && i3 == 40);
xmlrpc_decompose_value(&env, arrayP, "(i(ii*)i)", &i1, &i2, &i3, &i4);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, arrayP, "(i(iii)i)", &i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(i)i)", &i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(ii)i*i)",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i(iiQ)i*i)",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_decompose_value(&env, arrayP, "(i*",
&i1, &i2, &i3, &i4, &i5);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Test bounds check on xmlrpc_array_get_item. */
xmlrpc_array_read_item(&env, arrayP, 3, &itemP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_array_get_item(&env, arrayP, 3);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_array_get_item(&env, arrayP, -1);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_DECREF(arrayP);
xmlrpc_env_clean(&env);
}
static void
test_struct (void) {
xmlrpc_env env;
xmlrpc_value * value1P;
xmlrpc_value *s, *i, *i1, *i2, *i3, *key, *value;
size_t size;
int present;
xmlrpc_bool bval;
char const weirdKey[] = {'f', 'o', 'o', '\0', 'b', 'a', 'r'};
xmlrpc_env_init(&env);
/* Create a struct. */
s = xmlrpc_struct_new(&env);
TEST_NO_FAULT(&env);
TEST(s != NULL);
TEST(XMLRPC_TYPE_STRUCT == xmlrpc_value_type(s));
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 0);
/* Create some elements to insert into our struct. */
i1 = xmlrpc_build_value(&env, "s", "Item #1");
TEST_NO_FAULT(&env);
i2 = xmlrpc_build_value(&env, "s", "Item #2");
TEST_NO_FAULT(&env);
i3 = xmlrpc_build_value(&env, "s", "Item #3");
TEST_NO_FAULT(&env);
/* Insert a single item. */
xmlrpc_struct_set_value(&env, s, "foo", i1);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 1);
/* Insert an item whose key has the same hash value as "foo". */
xmlrpc_struct_set_value(&env, s, "qmdebdw", i2);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 2);
i = xmlrpc_struct_get_value(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(i == i1);
i = xmlrpc_struct_get_value(&env, s, "qmdebdw");
TEST_NO_FAULT(&env);
TEST(i == i2);
/* Replace an existing element with a different element. */
xmlrpc_struct_set_value(&env, s, "foo", i3);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 2);
i = xmlrpc_struct_get_value(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(i == i3);
/* Insert an item with a NUL in the key */
xmlrpc_struct_set_value_n(&env, s, weirdKey, sizeof(weirdKey), i2);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 3);
test_struct_get_element(s, i3, i2, weirdKey, sizeof(weirdKey));
/* Replace an existing element with the same element (tricky). */
xmlrpc_struct_set_value(&env, s, "foo", i3);
TEST_NO_FAULT(&env);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 3);
i = xmlrpc_struct_get_value(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(i == i3);
/* Test for the presence and absence of elements. */
present = xmlrpc_struct_has_key(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "qmdebdw");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "bogus");
TEST_NO_FAULT(&env);
TEST(!present);
/* Make sure our typechecks work correctly. */
xmlrpc_struct_size(&env, i1);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_struct_has_key(&env, i1, "foo");
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_struct_set_value(&env, i1, "foo", i2);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_struct_set_value_v(&env, s, s, i2);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
/* Test cleanup code (w/memprof). */
xmlrpc_DECREF(s);
s = xmlrpc_build_value(&env, "{s:s,s:i,s:b}",
"foo", "Hello!",
"bar", (xmlrpc_int32) 1,
"baz", (xmlrpc_bool) 0);
TEST_NO_FAULT(&env);
TEST(s != NULL);
TEST(xmlrpc_value_type(s) == XMLRPC_TYPE_STRUCT);
size = xmlrpc_struct_size(&env, s);
TEST_NO_FAULT(&env);
TEST(size == 3);
present = xmlrpc_struct_has_key(&env, s, "foo");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "bar");
TEST_NO_FAULT(&env);
TEST(present);
present = xmlrpc_struct_has_key(&env, s, "baz");
TEST_NO_FAULT(&env);
TEST(present);
xmlrpc_struct_read_value(&env, s, "baz", &value1P);
TEST_NO_FAULT(&env);
xmlrpc_read_bool(&env, value1P, &bval);
TEST_NO_FAULT(&env);
TEST(!bval);
xmlrpc_DECREF(value1P);
testStructReadout(s, 3);
test_struct_decompose(s);
/* Test type check. */
xmlrpc_struct_get_key_and_value(&env, i1, 0, &key, &value);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
TEST(key == NULL && value == NULL);
/* Test bounds checks. */
xmlrpc_struct_get_key_and_value(&env, s, -1, &key, &value);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
TEST(key == NULL && value == NULL);
xmlrpc_struct_get_key_and_value(&env, s, 3, &key, &value);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
TEST(key == NULL && value == NULL);
/* Test cleanup code (w/memprof). */
xmlrpc_DECREF(s);
xmlrpc_DECREF(i1);
xmlrpc_DECREF(i2);
xmlrpc_DECREF(i3);
xmlrpc_env_clean(&env);
}
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);
}
