void test(double fltval)
{
xmlrpc_env env;
xmlrpc_mem_block *ser;
xmlrpc_value *val;
char *blk;
printf("Starting with %f\n", fltval);
for(;fabs(fltval)>DBL_EPSILON;fltval/=10) {
xmlrpc_env_init(&env);
ser=XMLRPC_MEMBLOCK_NEW(char,&env,0);
val=xmlrpc_double_new(&env, fltval);
xmlrpc_serialize_value(&env, ser, val);
blk=XMLRPC_MEMBLOCK_CONTENTS(char,ser);
blk[XMLRPC_MEMBLOCK_SIZE(char,ser)]='\0';
printf("%7g as (%u) '%s'\n", fltval, strlen(blk), blk);
XMLRPC_MEMBLOCK_FREE(char,ser);
xmlrpc_DECREF(val);
}
}
static void
test_serialize_double(void) {
/* Test serialize of a double. */
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block *output;
char * result;
/* serialized result, as asciiz string */
size_t resultLength;
/* Length in characters of the serialized result */
float serializedValue;
char nextChar;
int itemsMatched;
xmlrpc_env_init(&env);
/* Build a double to serialize */
v = xmlrpc_build_value(&env, "d", 3.14159);
TEST_NO_FAULT(&env);
/* Serialize the value. */
output = XMLRPC_TYPED_MEM_BLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_value(&env, output, v);
TEST_NO_FAULT(&env);
/* Make sure we serialized the correct value. Note that because
doubles aren't precise, this might serialize as 3.1415899999
or something like that. So we check it arithmetically.
*/
resultLength = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);
result = malloc(resultLength + 1);
memcpy(result, XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output),
resultLength);
result[resultLength] = '\0';
itemsMatched = sscanf(result,
"<value><double>%f</double></value>\r\n%c",
&serializedValue, &nextChar);
TEST(itemsMatched == 1);
TEST(serializedValue - 3.14159 < .000001);
/* We'd like to test more precision, but sscanf doesn't do doubles */
free(result);
/* Clean up our value. */
XMLRPC_TYPED_MEM_BLOCK_FREE(char, output);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
testOneDouble(double const value) {
/* Test serialize of a double. */
xmlrpc_env env;
xmlrpc_value * valueP;
xmlrpc_mem_block * serializedP;
char * result;
/* serialized result, as asciiz string */
size_t resultLength;
/* Length in characters of the serialized result */
double serializedValue;
char nextChar;
int itemsMatched;
xmlrpc_env_init(&env);
/* Build a double to serialize */
valueP = xmlrpc_double_new(&env, value);
TEST_NO_FAULT(&env);
/* Serialize the value. */
serializedP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_value(&env, serializedP, valueP);
TEST_NO_FAULT(&env);
/* Make sure we serialized the correct value. Note that because
doubles aren't precise, this might serialize as 3.1415899999
or something like that. So we check it arithmetically.
*/
resultLength = XMLRPC_MEMBLOCK_SIZE(char, serializedP);
result = malloc(resultLength + 1);
memcpy(result, XMLRPC_MEMBLOCK_CONTENTS(char, serializedP), resultLength);
result[resultLength] = '\0';
itemsMatched = sscanf(result,
"<value><double>%lf</double></value>\r\n%c",
&serializedValue, &nextChar);
TEST(itemsMatched == 1);
TESTFLOATEQUAL(serializedValue, value);
free(result);
/* Clean up our value. */
XMLRPC_TYPED_MEM_BLOCK_FREE(char, serializedP);
xmlrpc_DECREF(valueP);
xmlrpc_env_clean(&env);
}
static void
test_serialize_basic(void) {
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block *output;
size_t size;
xmlrpc_env_init(&env);
/* Build a nice, messy value to serialize. We should attempt to use
** use every data type except double (which doesn't serialize in a
** portable manner. */
v = xmlrpc_build_value(&env, "(iibbs68())",
(xmlrpc_int32) INT_MAX, (xmlrpc_int32) INT_MIN,
(xmlrpc_bool) 0, (xmlrpc_bool) 1,
"Hello, world! <&>",
"base64 data", (size_t) 11,
"19980717T14:08:55");
TEST_NO_FAULT(&env);
/* Serialize the value. */
output = XMLRPC_TYPED_MEM_BLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_value(&env, output, v);
TEST_NO_FAULT(&env);
/* Make sure we serialized the correct value. */
size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);
TEST(size == strlen(serialized_data));
TEST(memcmp(XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output),
serialized_data, size) == 0);
/* (Debugging code to display the value.) */
/* XMLRPC_TYPED_MEM_BLOCK_APPEND(char, &env, output, "\0", 1);
** TEST_NO_FAULT(&env);
** printf("%s\n", XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output)); */
/* Clean up our value. */
XMLRPC_TYPED_MEM_BLOCK_FREE(char, output);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_serialize_struct(void) {
/* Serialize a simple struct. */
char const serialized_struct[] =
"<value><struct>\r\n" \
"<member><name><&></name>\r\n" \
"<value><i4>10</i4></value></member>\r\n" \
"</struct></value>";
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block *output;
size_t size;
xmlrpc_env_init(&env);
v = xmlrpc_build_value(&env, "{s:i}", "<&>", (xmlrpc_int32) 10);
TEST_NO_FAULT(&env);
output = XMLRPC_TYPED_MEM_BLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_value(&env, output, v);
TEST_NO_FAULT(&env);
/* Make sure we serialized the correct value. */
size = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);
TEST(size == strlen(serialized_struct));
TEST(memcmp(XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output),
serialized_struct, size) == 0);
/* Clean up our struct. */
XMLRPC_TYPED_MEM_BLOCK_FREE(char, output);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
static void
test_serialize_string(void) {
/* Test serialize of a string, including all the line ending
complexity.
*/
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block * xmlP; /* Serialized result */
xmlrpc_env_init(&env);
TEST_NO_FAULT(&env);
v = xmlrpc_string_new(&env, "hello world");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>hello world</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new(&env, "");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string></string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 7, "foo\0bar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\0bar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 7, "foo\nbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\nbar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 8, "foo\r\nbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\nbar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp(&env, 7, "foo\rbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo\nbar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
v = xmlrpc_string_new_lp_cr(&env, 7, "foo\rbar");
TEST_NO_FAULT(&env);
xmlP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
xmlrpc_serialize_value(&env, xmlP, v);
TEST_NO_FAULT(&env);
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, xmlP),
"<value><string>foo
bar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
xmlrpc_DECREF(v);
xmlrpc_env_clean(&env);
}
