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_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_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); 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(memcmp(data, data1, sizeof(data1)) == 0); 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(memcmp(data, data1, sizeof(data2)) == 0); strfree(data); xmlrpc_env_clean(&env); }
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_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); }
static void test_value_value(void) { xmlrpc_value *v, *v2, *v3; xmlrpc_env env; /* Test 'V' with building and parsing. */ xmlrpc_env_init(&env); v2 = xmlrpc_int_new(&env, (xmlrpc_int32) 5); TEST_NO_FAULT(&env); v = xmlrpc_build_value(&env, "V", v2); TEST_NO_FAULT(&env); TEST(v == v2); xmlrpc_decompose_value(&env, v2, "V", &v3); xmlrpc_DECREF(v); TEST_NO_FAULT(&env); TEST(v2 == v3); xmlrpc_DECREF(v3); xmlrpc_DECREF(v2); xmlrpc_env_clean(&env); }
static void test_value_alloc_dealloc(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_env_init(&env); /* Test allocation and deallocation (w/memprof). */ v = xmlrpc_build_value(&env, "i", (xmlrpc_int32) 5); TEST_NO_FAULT(&env); TEST(v != NULL); xmlrpc_INCREF(v); xmlrpc_DECREF(v); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
static void test_value_datetime_not_unix(const char * const datestring) { xmlrpc_value * v; xmlrpc_env env; time_t dt; xmlrpc_env_init(&env); v = xmlrpc_datetime_new_str(&env, datestring); TEST_NO_FAULT(&env); xmlrpc_read_datetime_sec(&env, v, &dt); TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
static void test_expat (void) { xmlrpc_env env; xml_element *elem, *array, *data, *value1, *i4; char *cdata; size_t size; xmlrpc_env_init(&env); /* Parse a moderately complex XML document. */ xml_parse(&env, expat_data, strlen(expat_data), &elem); TEST_NO_FAULT(&env); TEST(elem != NULL); /* Verify our results. */ TEST(streq(xml_element_name(elem), "value")); TEST(xml_element_children_size(elem) == 1); array = xml_element_children(elem)[0]; TEST(streq(xml_element_name(array), "array")); TEST(xml_element_children_size(array) == 1); data = xml_element_children(array)[0]; TEST(streq(xml_element_name(data), "data")); TEST(xml_element_children_size(data) > 1); value1 = xml_element_children(data)[0]; TEST(streq(xml_element_name(value1), "value")); TEST(xml_element_children_size(value1) == 1); i4 = xml_element_children(value1)[0]; TEST(streq(xml_element_name(i4), "i4")); TEST(xml_element_children_size(i4) == 0); cdata = xml_element_cdata(i4); size = xml_element_cdata_size(i4); TEST(size == strlen("2147483647")); TEST(memcmp(cdata, "2147483647", strlen("2147483647")) == 0); /* Test cleanup code (w/memprof). */ xml_element_free(elem); /* Test broken XML */ xml_parse(&env, expat_error_data, strlen(expat_error_data), &elem); TEST(env.fault_occurred); xmlrpc_env_clean(&env); }
static void testParseBadResult(void) { /*---------------------------------------------------------------------------- Test parsing of data that is supposed to be a response, but is not valid. It looks like a valid success response, but the result value is not valid XML-RPC. -----------------------------------------------------------------------------*/ unsigned int i; for (i = 0; bad_values[i] != NULL; ++i) { const char * const bad_resp = bad_values[i]; xmlrpc_env env; xmlrpc_value * valueP; xml_element *elem; int faultCode; const char * faultString; xmlrpc_env_init(&env); /* First, check to make sure that our test case is well-formed XML. ** (It's easy to make mistakes when writing the test cases!) */ xml_parse(&env, bad_resp, strlen(bad_resp), &elem); TEST_NO_FAULT(&env); xml_element_free(elem); /* Now, make sure the higher-level routine barfs appropriately. */ xmlrpc_parse_response2(&env, bad_resp, strlen(bad_resp), &valueP, &faultCode, &faultString); TEST_FAULT(&env, XMLRPC_PARSE_ERROR); xmlrpc_env_clean(&env); xmlrpc_env_init(&env); /* And again with the old interface */ valueP = xmlrpc_parse_response(&env, bad_resp, strlen(bad_resp)); TEST_FAULT(&env, XMLRPC_PARSE_ERROR); TEST(valueP == NULL); xmlrpc_env_clean(&env); } }
static void testParseFaultResponse(void) { /*---------------------------------------------------------------------------- Test parsing of a valid response that indicates the RPC failed. -----------------------------------------------------------------------------*/ xmlrpc_env env; xmlrpc_env_init(&env); { xmlrpc_value * resultP; int faultCode; const char * faultString; xmlrpc_parse_response2(&env, serialized_fault, strlen(serialized_fault), &resultP, &faultCode, &faultString); TEST_NO_FAULT(&env); TEST(faultString != NULL); TEST(faultCode == 6); TEST(streq(faultString, "A fault occurred")); strfree(faultString); } /* Now with the old interface */ { xmlrpc_value * valueP; xmlrpc_env fault; /* Parse a valid fault. */ xmlrpc_env_init(&fault); valueP = xmlrpc_parse_response(&fault, serialized_fault, strlen(serialized_fault)); TEST(fault.fault_occurred); TEST(fault.fault_code == 6); TEST(streq(fault.fault_string, "A fault occurred")); xmlrpc_env_clean(&fault); } 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_type_mismatch(void) { xmlrpc_value * v; xmlrpc_env env; xmlrpc_env env2; char * str; /* Test for one, simple kind of type mismatch error. We assume that ** if one of these typechecks works, the rest work fine. */ xmlrpc_env_init(&env); xmlrpc_env_init(&env2); v = xmlrpc_build_value(&env, "i", (xmlrpc_int32) 5); TEST_NO_FAULT(&env); xmlrpc_decompose_value(&env2, v, "s", &str); xmlrpc_DECREF(v); TEST_FAULT(&env2, XMLRPC_TYPE_ERROR); xmlrpc_env_clean(&env2); xmlrpc_env_clean(&env); }
static void test_sample_files (void) { xmlrpc_env env; char **paths, *path; char *data; size_t data_len; const char *method_name; xmlrpc_value *params; xmlrpc_env_init(&env); /* Test our good requests. */ for (paths = good_requests; *paths != NULL; paths++) { path = *paths; read_file(path, &data, &data_len); xmlrpc_parse_call(&env, data, data_len, &method_name, ¶ms); TEST_NO_FAULT(&env); strfree(method_name); xmlrpc_DECREF(params); } xmlrpc_env_clean(&env); }
static void test_value_AS_typecheck(void) { xmlrpc_env env; xmlrpc_env env2; xmlrpc_value *v; xmlrpc_value *v2; /* Test typechecks for 'A' and 'S'. */ xmlrpc_env_init(&env); xmlrpc_env_init(&env2); v = xmlrpc_build_value(&env, "s", "foo"); TEST_NO_FAULT(&env); xmlrpc_decompose_value(&env2, v, "A", &v2); TEST_FAULT(&env2, XMLRPC_TYPE_ERROR); xmlrpc_decompose_value(&env2, v, "S", &v2); TEST_FAULT(&env2, XMLRPC_TYPE_ERROR); xmlrpc_DECREF(v); xmlrpc_env_clean(&env2); xmlrpc_env_clean(&env); }
static void testFailedParseValue(void) { xmlrpc_env env; xmlrpc_value * valueP; const char * stringval; int integerval; xmlrpc_env_init(&env); valueP = xmlrpc_build_value(&env, "{s:s}", "string", "stringval"); TEST_NO_FAULT(&env); /* Fail because "integer" member is missing */ xmlrpc_parse_value(&env, valueP, "{s:s,s:i,*}", "string", &stringval, "integer", &integerval); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); xmlrpc_DECREF(valueP); xmlrpc_env_clean(&env); }
static void testParseBadResponseXmlRpc(void) { /*---------------------------------------------------------------------------- Test parsing of data that is supposed to be a response, and is valid XML, but is not valid XML-RPC. -----------------------------------------------------------------------------*/ unsigned int i; /* For this test, we test up to but not including the <value> in a successful RPC response. */ /* Next, check for bogus responses. These are all well-formed XML, but ** they aren't legal XML-RPC. */ for (i = 15; bad_responses[i] != NULL; ++i) { const char * const bad_resp = bad_responses[i]; xmlrpc_env env; xmlrpc_value * v; xml_element *elem; xmlrpc_env_init(&env); /* First, check to make sure that our test case is well-formed XML. ** (It's easy to make mistakes when writing the test cases!) */ xml_parse(&env, bad_resp, strlen(bad_resp), &elem); TEST_NO_FAULT(&env); xml_element_free(elem); /* Now, make sure the higher-level routine barfs appropriately. */ v = xmlrpc_parse_response(&env, bad_resp, strlen(bad_resp)); TEST(env.fault_occurred); TEST(env.fault_code != 0); /* We use 0 as a code in our bad faults. */ TEST(v == NULL); 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_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 testParseNumberValue(void) { char const xmldata[] = XML_PROLOGUE "<methodCall>\r\n" "<methodName>test</methodName>\r\n" "<params>\r\n" "<param><value><int>2147483647</int></value></param>\r\n" \ "<param><value><int>-2147483648</int></value></param>\r\n" \ "<param><value><i1>10</i1></value></param>\r\n" "<param><value><i2>10</i2></value></param>\r\n" "<param><value><i4>10</i4></value></param>\r\n" "<param><value><i8>10</i8></value></param>\r\n" "<param><value><ex:i8>10</ex:i8></value></param>\r\n" "<param><value><double>10</double></value></param>\r\n" "<param><value><double>10.1</double></value></param>\r\n" "<param><value><double>-10.1</double></value></param>\r\n" "<param><value><double>+10.1</double></value></param>\r\n" "<param><value><double>0</double></value></param>\r\n" "<param><value><double>.01</double></value></param>\r\n" "<param><value><double>5.</double></value></param>\r\n" "<param><value><double>5.3E6</double></value></param>\r\n" "<param><value><double> 1</double></value></param>\r\n" "</params>\r\n" "</methodCall>\r\n"; xmlrpc_env env; xmlrpc_value * paramArrayP; const char * methodName; int arraySize; xmlrpc_int int_max, int_min; xmlrpc_int32 i_i1, i_i2, i_i4; xmlrpc_int64 i_i8, i_ex_i8; double d1, d2, d3, d4, d5, d6, d7, d8, d9; xmlrpc_env_init(&env); xmlrpc_parse_call(&env, xmldata, strlen(xmldata), &methodName, ¶mArrayP); TEST_NO_FAULT(&env); arraySize = xmlrpc_array_size(&env, paramArrayP); TEST_NO_FAULT(&env); TEST(arraySize == 16); xmlrpc_decompose_value( &env, paramArrayP, "(iiiiiIIddddddddd)", &int_max, &int_min, &i_i1, &i_i2, &i_i4, &i_i8, &i_ex_i8, &d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9); TEST_NO_FAULT(&env); TEST(int_max == INT_MAX); TEST(int_min == INT_MIN); TEST(i_i1 == 10); TEST(i_i2 == 10); TEST(i_i4 == 10); TEST(i_i8 == 10); TEST(i_ex_i8 == 10); TESTFLOATEQUAL(d1, 10.0); TESTFLOATEQUAL(d2, 10.1); TESTFLOATEQUAL(d3, -10.1); TESTFLOATEQUAL(d4, +10.1); TESTFLOATEQUAL(d5, 0.0); TESTFLOATEQUAL(d6, 0.01); TESTFLOATEQUAL(d7, 5.0); TESTFLOATEQUAL(d8, 5.3E6); TESTFLOATEQUAL(d9, 1.0); xmlrpc_DECREF(paramArrayP); strfree(methodName); xmlrpc_env_clean(&env); }
static void test_struct_decompose(xmlrpc_value * const testStructP) { xmlrpc_env env; xmlrpc_int32 ival; xmlrpc_bool bval; char * sval; xmlrpc_value * topStructP; xmlrpc_value * value1P; xmlrpc_env_init(&env); /* Make a test struct */ topStructP = xmlrpc_build_value(&env, "{s:S,s:s}", "key1", testStructP, "key2", "my_string_value"); TEST_NO_FAULT(&env); test_struct_decompose_invalid_format_string(testStructP); /* Decompose a struct */ xmlrpc_decompose_value(&env, testStructP, "{s:b,s:s,s:i,*}", "baz", &bval, "foo", &sval, "bar", &ival); TEST_NO_FAULT(&env); TEST(ival == 1); TEST(!bval); TEST(streq(sval, "Hello!")); free(sval); /* Decompose a deep struct */ xmlrpc_decompose_value(&env, topStructP, "{s:S,*}", "key1", &value1P); TEST_NO_FAULT(&env); TEST(xmlrpc_value_type(value1P) == XMLRPC_TYPE_STRUCT); xmlrpc_DECREF(value1P); xmlrpc_decompose_value(&env, topStructP, "{s:{s:b,s:s,s:i,*},*}", "key1", "baz", &bval, "foo", &sval, "bar", &ival); TEST_NO_FAULT(&env); TEST(ival == 1); TEST(!bval); TEST(streq(sval, "Hello!")); free(sval); /* First value of wrong type */ xmlrpc_decompose_value(&env, testStructP, "{s:b,s:i,*}", "baz", &sval, "foo", &ival); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* Subsequent value of wrong type */ xmlrpc_decompose_value(&env, testStructP, "{s:s,s:i,*}", "foo", &sval, "baz", &bval); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* Nonexistent key */ xmlrpc_decompose_value(&env, testStructP, "{s:b,s:i,*}", "baz", &bval, "nosuch", &sval); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); /* Error subsequent to nested value */ xmlrpc_decompose_value(&env, topStructP, "{s:{s:s,*},s:i,*}", "key1", "foo", &sval, "key2", &ival); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); xmlrpc_DECREF(topStructP); 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 validateParseResponseResult(xmlrpc_value * const valueP) { xmlrpc_env env; xmlrpc_value * s; xmlrpc_int32 int_max; xmlrpc_int32 int_min; xmlrpc_int32 int_one; xmlrpc_bool bool_false; xmlrpc_bool bool_true; char * str_hello; char * str_untagged; char * datetime; unsigned char * b64_data; size_t b64_len; double negone; double zero; double one; xmlrpc_env_init(&env); xmlrpc_decompose_value( &env, valueP, "((iibbs68())idddSs)", &int_max, &int_min, &bool_false, &bool_true, &str_hello, &b64_data, &b64_len, &datetime, &int_one, &negone, &zero, &one, &s, &str_untagged); TEST_NO_FAULT(&env); TEST(int_max == INT_MAX); TEST(int_min == INT_MIN); TEST(!bool_false); TEST(bool_true); TEST(strlen(str_hello) == strlen("Hello, world! <&>")); TEST(streq(str_hello, "Hello, world! <&>")); TEST(b64_len == 11); TEST(memcmp(b64_data, "base64 data", b64_len) == 0); TEST(streq(datetime, "19980717T14:08:55")); TEST(int_one == 1); TEST(negone == -1.0); TEST(zero == 0.0); TEST(one == 1.0); TEST(streq(str_untagged, "Untagged string")); free(str_hello); free(b64_data); free(datetime); free(str_untagged); { /* Analyze the contents of our struct. */ xmlrpc_value * sval; int size, sval_int; TEST(s != NULL); size = xmlrpc_struct_size(&env, s); TEST_NO_FAULT(&env); TEST(size == 2); sval = xmlrpc_struct_get_value(&env, s, "ten <&>"); TEST_NO_FAULT(&env); xmlrpc_decompose_value(&env, sval, "i", &sval_int); TEST_NO_FAULT(&env); TEST(sval_int == 10); sval = xmlrpc_struct_get_value(&env, s, "twenty"); TEST_NO_FAULT(&env); xmlrpc_decompose_value(&env, sval, "i", &sval_int); TEST_NO_FAULT(&env); TEST(sval_int == 20); xmlrpc_DECREF(s); } xmlrpc_env_clean(&env); }
static void testParseMiscSimpleValue(void) { char const xmldata[] = XML_PROLOGUE "<methodCall>\r\n" "<methodName>test</methodName>\r\n" "<params>\r\n" "<param><value><string>hello</string></value></param>\r\n" "<param><value><boolean>0</boolean></value></param>\r\n" "<param><value><boolean>1</boolean></value></param>\r\n" "<param><value><dateTime.iso8601>19980717T14:08:55</dateTime.iso8601>" "</value></param>\r\n" "<param><value>" "<dateTime.iso8601>19980717T14:08:55.123456</dateTime.iso8601>" "</value></param>\r\n" "<param><value><base64>YmFzZTY0IGRhdGE=</base64></value></param>\r\n" "<param><value><nil/></value></param>\r\n" "<param><value><ex:nil/></value></param>\r\n" "</params>\r\n" "</methodCall>\r\n"; xmlrpc_env env; xmlrpc_value * paramArrayP; const char * methodName; int arraySize; const char * str_hello; xmlrpc_bool b_false, b_true; const char * datetime_sec; const char * datetime_usec; unsigned char * b64_data; size_t b64_len; xmlrpc_env_init(&env); xmlrpc_parse_call(&env, xmldata, strlen(xmldata), &methodName, ¶mArrayP); TEST_NO_FAULT(&env); arraySize = xmlrpc_array_size(&env, paramArrayP); TEST_NO_FAULT(&env); TEST(arraySize == 8); xmlrpc_decompose_value( &env, paramArrayP, "(sbb886nn)", &str_hello, &b_false, &b_true, &datetime_sec, &datetime_usec, &b64_data, &b64_len); TEST_NO_FAULT(&env); TEST(streq(str_hello, "hello")); TEST(!b_false); TEST(b_true); TEST(streq(datetime_sec, "19980717T14:08:55")); TEST(streq(datetime_usec, "19980717T14:08:55.123456")); TEST(b64_len == 11); TEST(memcmp(b64_data, "base64 data", b64_len) == 0); free(b64_data); strfree(str_hello); strfree(datetime_sec); strfree(datetime_usec); xmlrpc_DECREF(paramArrayP); strfree(methodName); 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); }
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_get_element(xmlrpc_value * const structP, xmlrpc_value * const fooValueP, xmlrpc_value * const weirdValueP, const char * const weirdKey, unsigned int const weirdKeyLen) { xmlrpc_env env; xmlrpc_value * valueP; xmlrpc_value * fooStringP; xmlrpc_value * bogusKeyStringP; xmlrpc_env_init(&env); /* build test tools */ fooStringP = xmlrpc_build_value(&env, "s", "foo"); TEST_NO_FAULT(&env); bogusKeyStringP = xmlrpc_build_value(&env, "s", "doesn't_exist"); TEST_NO_FAULT(&env); /* "find" interface */ xmlrpc_struct_find_value(&env, structP, "foo", &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_find_value(&env, structP, "doesn't_exist", &valueP); TEST_NO_FAULT(&env); TEST(valueP == NULL); xmlrpc_struct_find_value_v(&env, structP, fooStringP, &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_find_value_v(&env, structP, bogusKeyStringP, &valueP); TEST_NO_FAULT(&env); TEST(valueP == NULL); xmlrpc_struct_find_value(&env, fooValueP, "foo", &valueP); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* "read" interface */ xmlrpc_struct_read_value(&env, structP, "foo", &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_read_value(&env, structP, "doesn't_exist", &valueP); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); xmlrpc_struct_read_value_v(&env, structP, fooStringP, &valueP); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); xmlrpc_DECREF(valueP); xmlrpc_struct_read_value_v(&env, structP, bogusKeyStringP, &valueP); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); xmlrpc_struct_read_value(&env, fooValueP, "foo", &valueP); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); /* obsolete "get" interface. Note that it does not update the reference count of the xmlrpc_value it returns. */ valueP = xmlrpc_struct_get_value(&env, structP, "foo"); TEST_NO_FAULT(&env); TEST(valueP == fooValueP); valueP = xmlrpc_struct_get_value(&env, structP, "doesn't_exist"); TEST_FAULT(&env, XMLRPC_INDEX_ERROR); valueP = xmlrpc_struct_get_value(&env, fooValueP, "foo"); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); valueP = xmlrpc_struct_get_value_n(&env, structP, weirdKey, weirdKeyLen); TEST_NO_FAULT(&env); TEST(valueP == weirdValueP); /* Clean up */ xmlrpc_DECREF(fooStringP); xmlrpc_DECREF(bogusKeyStringP); xmlrpc_env_clean(&env); }
static void test_value_string_multiline(void) { xmlrpc_env env; xmlrpc_value * v; const char * str; size_t len; xmlrpc_env_init(&env); /* LF line ending */ v = xmlrpc_string_new(&env, "foo\n"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\n")); strfree(str); xmlrpc_read_string_crlf(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\r\n")); strfree(str); xmlrpc_DECREF(v); v = xmlrpc_string_new(&env, "foo\n\n"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\n\n")); strfree(str); xmlrpc_read_string_crlf(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\r\n\r\n")); strfree(str); xmlrpc_DECREF(v); v = xmlrpc_string_new(&env, "foo\nbar"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar")); strfree(str); xmlrpc_read_string_crlf(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\r\nbar")); strfree(str); xmlrpc_DECREF(v); v = xmlrpc_string_new(&env, "foo\nbar\n"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar\n")); strfree(str); xmlrpc_read_string_crlf(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\r\nbar\r\n")); strfree(str); xmlrpc_DECREF(v); v = xmlrpc_string_new(&env, "foo\nbar\nbaz"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar\nbaz")); strfree(str); xmlrpc_read_string_crlf(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\r\nbar\r\nbaz")); strfree(str); xmlrpc_DECREF(v); /* CR line ending */ v = xmlrpc_string_new(&env, "foo\r"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\n")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\r\r"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\n\n")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\rbar"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\rbar\r"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar\n")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\rbar\rbaz"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar\nbaz")); xmlrpc_DECREF(v); strfree(str); /* CRLF line ending */ v = xmlrpc_string_new(&env, "foo\r\n"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\n")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\r\n\r\n"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\n\n")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\r\nbar"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\r\nbar\r\n"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar\n")); xmlrpc_DECREF(v); strfree(str); v = xmlrpc_string_new(&env, "foo\r\nbar\r\nbaz"); TEST_NO_FAULT(&env); xmlrpc_read_string(&env, v, &str); TEST_NO_FAULT(&env); TEST(streq(str, "foo\nbar\nbaz")); xmlrpc_DECREF(v); strfree(str); /* Embedded null */ v = xmlrpc_string_new_lp(&env, 14, "foo\r\n\0bar\r\nbaz"); TEST_NO_FAULT(&env); xmlrpc_read_string_lp(&env, v, &len, &str); TEST_NO_FAULT(&env); TEST(len == 12); TEST(memeq(str, "foo\n\0bar\nbaz", len)); strfree(str); xmlrpc_read_string_lp_crlf(&env, v, &len, &str); TEST_NO_FAULT(&env); TEST(len == 14); TEST(memeq(str, "foo\r\n\0bar\r\nbaz", len)); strfree(str); xmlrpc_DECREF(v); xmlrpc_env_clean(&env); }
static void test_utf8_coding(void) { #if HAVE_UNICODE_WCHAR xmlrpc_env env, env2; utf8_and_wcs *good_data; char **bad_data; char *utf8; wchar_t *wcs; xmlrpc_mem_block *output; xmlrpc_env_init(&env); /* Test each of our valid UTF-8 sequences. */ for (good_data = good_utf8; good_data->utf8 != NULL; good_data++) { utf8 = good_data->utf8; wcs = good_data->wcs; /* Attempt to validate the UTF-8 string. */ xmlrpc_validate_utf8(&env, utf8, strlen(utf8)); TEST_NO_FAULT(&env); /* Attempt to decode the UTF-8 string. */ output = xmlrpc_utf8_to_wcs(&env, utf8, strlen(utf8)); TEST_NO_FAULT(&env); TEST(output != NULL); TEST(wcslen(wcs) == XMLRPC_TYPED_MEM_BLOCK_SIZE(wchar_t, output)); TEST(0 == wcsncmp(wcs, XMLRPC_TYPED_MEM_BLOCK_CONTENTS(wchar_t, output), wcslen(wcs))); xmlrpc_mem_block_free(output); /* Test the UTF-8 encoder, too. */ output = xmlrpc_wcs_to_utf8(&env, wcs, wcslen(wcs)); TEST_NO_FAULT(&env); TEST(output != NULL); TEST(strlen(utf8) == XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output)); TEST(0 == strncmp(utf8, XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output), strlen(utf8))); xmlrpc_mem_block_free(output); } /* Test each of our illegal UTF-8 sequences. */ for (bad_data = bad_utf8; *bad_data != NULL; bad_data++) { utf8 = *bad_data; /* Attempt to validate the UTF-8 string. */ xmlrpc_env_init(&env2); xmlrpc_validate_utf8(&env2, utf8, strlen(utf8)); TEST_FAULT(&env2, XMLRPC_INVALID_UTF8_ERROR); /* printf("Fault: %s\n", env2.fault_string); --Hand-checked */ xmlrpc_env_clean(&env2); /* Attempt to decode the UTF-8 string. */ xmlrpc_env_init(&env2); output = xmlrpc_utf8_to_wcs(&env2, utf8, strlen(utf8)); TEST_FAULT(&env2, XMLRPC_INVALID_UTF8_ERROR); TEST(output == NULL); xmlrpc_env_clean(&env2); } xmlrpc_env_clean(&env); #endif /* HAVE_UNICODE_WCHAR */ }
static void test_value_string_wide(void) { #if HAVE_UNICODE_WCHAR xmlrpc_env env; xmlrpc_value * valueP; const wchar_t * wcs; size_t len; xmlrpc_env_init(&env); /* Build a string from wchar_t data. */ valueP = xmlrpc_string_w_new_lp(&env, 3, wcs_data); TEST_NO_FAULT(&env); TEST(valueP != NULL); /* Extract it as a wchar_t string. */ xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 3); TEST(wcs[len] == '\0'); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); xmlrpc_read_string_w(&env, valueP, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(wcs[3] == '\0'); TEST(wcsneq(wcs, wcs_data, 3)); free((void*)wcs); xmlrpc_decompose_value(&env, valueP, "w#", &wcs, &len); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 3); TEST(wcs[len] == '\0'); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); { /* Extract it as a UTF-8 string. */ const char * str; size_t len; xmlrpc_read_string_lp(&env, valueP, &len, &str); TEST_NO_FAULT(&env); TEST(str != NULL); TEST(len == 4); TEST(str[len] == '\0'); TEST(xmlrpc_strneq(str, utf8_data, len)); free((void*)str); } xmlrpc_DECREF(valueP); /* Build from null-terminated wchar_t string */ valueP = xmlrpc_string_w_new(&env, wcs_data); TEST_NO_FAULT(&env); TEST(valueP != NULL); /* Verify it */ xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 3); TEST(wcs[len] == '\0'); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); xmlrpc_DECREF(valueP); test_value_string_wide_build(); /* Build a string from UTF-8 data. */ valueP = xmlrpc_string_new(&env, utf8_data); TEST_NO_FAULT(&env); TEST(valueP != NULL); /* Extract it as a wchar_t string. */ xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 3); TEST(wcs[len] == 0x0000); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); xmlrpc_DECREF(valueP); /* Test with embedded NUL. We use a length of 4 so that the terminating NUL actually becomes part of the string. */ valueP = xmlrpc_string_w_new_lp(&env, 4, wcs_data); TEST_NO_FAULT(&env); TEST(valueP != NULL); /* Extract it as a wchar_t string. */ xmlrpc_read_string_w_lp(&env, valueP, &len, &wcs); TEST_NO_FAULT(&env); TEST(wcs != NULL); TEST(len == 4); TEST(wcs[len] == '\0'); TEST(wcsneq(wcs, wcs_data, len)); free((void*)wcs); xmlrpc_read_string_w(&env, valueP, &wcs); TEST_FAULT(&env, XMLRPC_TYPE_ERROR); xmlrpc_DECREF(valueP); test_value_string_wide_line(); xmlrpc_env_clean(&env); #endif /* HAVE_UNICODE_WCHAR */ }