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);
}
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);
}
}
void
xr_setDoubleInResult (void *data, double val)
{
CallerP c = (Caller *) data;
if (c->result)
xmlrpc_DECREF (c->result);
if (!xr_errstat)
c->result = xmlrpc_double_new (c->env, val);
}
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
parseDouble(xmlrpc_env * const envP,
const char * const str,
xmlrpc_value ** const valuePP) {
/*----------------------------------------------------------------------------
Parse the content of a <double> XML-RPC XML element, e.g. "34.5".
'str' is that content.
-----------------------------------------------------------------------------*/
xmlrpc_env parseEnv;
double valueDouble;
XMLRPC_ASSERT_ENV_OK(envP);
XMLRPC_ASSERT_PTR_OK(str);
xmlrpc_env_init(&parseEnv);
parseDoubleString(&parseEnv, str, &valueDouble);
if (parseEnv.fault_occurred) {
/* As an alternative, try a strtod() parsing. strtod()
accepts other forms, e.g. "3.4E6"; "3,4"; " 3.4". These
are not permitted by XML-RPC, but an almost-XML-RPC partner
might use one. In fact, for many years, Xmlrpc-c generated
such alternatives (by mistake).
*/
bool failed;
parseDoubleStringStrtod(str, &failed, &valueDouble);
if (failed)
setParseFault(envP, "<double> element value '%s' is not a valid "
"floating point number. %s",
str, parseEnv.fault_string);
}
if (!envP->fault_occurred)
*valuePP = xmlrpc_double_new(envP, valueDouble);
xmlrpc_env_clean(&parseEnv);
}
cWrapper(double const cppvalue) {
env_wrap env;
this->valueP = xmlrpc_double_new(&env.env_c, cppvalue);
throwIfError(env);
}
