git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@8545 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Michael Jerris committed 2008-05-23 20:56:24 +00:00
1 parent d2290cfa3a
commit 00654d880e
338 files changed
+55722 -19397

No files matched your search

+97
View File
@@ -0,0 +1,97 @@
ifeq ($(SRCDIR),)
updir = $(shell echo $(dir $(1)) | sed 's/.$$//')
srcDIR := $(call updir,$(CURDIR))
SRCDIR := $(call updir,$(srcDIR))
BLDDIR := $(SRCDIR)
endif
SUBDIR := src/test
include $(BLDDIR)/config.mk
XMLRPC_C_CONFIG = $(BLDDIR)/xmlrpc-c-config.test
LDADD_CLIENT = \
$(shell $(XMLRPC_C_CONFIG) client --ldadd)
LDADD_ABYSS_SERVER = \
$(shell $(XMLRPC_C_CONFIG) abyss-server --ldadd)
LDADD_CGI_SERVER = \
$(shell $(XMLRPC_C_CONFIG) cgi-server --ldadd)
default: all
INCLUDES = -I$(BLDDIR) -I $(SRCDIR)/include -I$(SRCDIR)/lib/util/include \
PROGS = test cgitest1
all: $(PROGS)
LDFLAGS = $(LADD)
TEST_OBJS = \
test.o \
abyss.o \
cgi.o \
method_registry.o \
parse_xml.o \
serialize.o \
serialize_value.o \
server_abyss.o \
value.o \
xml_data.o \
ifeq ($(MUST_BUILD_CLIENT),yes)
TEST_OBJS += client.o
LIBXMLRPC_CLIENT_DEP = $(LIBXMLRPC_CLIENT_A)
else
TEST_OBJS += client_dummy.o
LIBXMLRPC_CLIENT_DEP =
endif
include $(SRCDIR)/common.mk
test: \
$(XMLRPC_C_CONFIG) \
$(TEST_OBJS) $(LIBXMLRPC_A) $(LIBXMLRPC_UTIL_A) \
$(LIBXMLRPC_SERVER_A) $(LIBXMLRPC_SERVER_ABYSS_A) $(LIBXMLRPC_XML) \
$(LIBXMLRPC_CLIENT_DEP) $(LIBXMLRPC_ABYSS_A) \
$(LIBXMLRPC_XMLPARSE_A) $(LIBXMLRPC_XMLTOK_A) \
$(CASPRINTF)
$(CCLD) -o $@ $(LDFLAGS) \
$(TEST_OBJS) $(LDADD_CLIENT) $(LDADD_ABYSS_SERVER) $(CASPRINTF)
cgitest1:%:%.o $(LIBXMLRPC_SERVER_A) $(LIBXMLRPC_SERVER_CGI_A) \
$(LIBXMLRPC_A) $(LIBXMLRPC_UTIL_A) $(LIBXMLRPC_XML)
$(CCLD) -o $@ $< $(LDFLAGS) $(LDADD_CGI_SERVER)
CFLAGS = $(CFLAGS_COMMON) $(CFLAGS_PERSONAL) $(CADD)
OBJS = $(TEST_OBJS) cgitest1.o
$(OBJS):%.o:%.c
$(CC) -c $(INCLUDES) $(CFLAGS) $<
# Note the difference between 'check' and 'runtests'. 'check' means to check
# our own correctness. 'runtests' means to run the tests that check our
# parent's correctness
.PHONY: check
check:
.PHONY: runtests
runtests: test cgitest1
./test
.PHONY: install
install:
.PHONY: clean clean-local distclean
clean: clean-common clean-local
clean-local:
rm -f $(PROGS)
distclean: clean distclean-common
.PHONY: dep
dep: dep-common
include Makefile.depend
+342
View File
@@ -0,0 +1,342 @@
/* None of the tests in here rely on a client existing, or even a network
connection. We should figure out how to create a test client and do
such tests.
*/
#include "unistdx.h"
#include <stdio.h>
#ifndef WIN32
#include <sys/socket.h>
#include <netinet/in.h>
#endif
#include <errno.h>
#include <string.h>
#include "xmlrpc_config.h"
#include "int.h"
#include "xmlrpc-c/base.h"
#include "xmlrpc-c/server.h"
#include "xmlrpc-c/abyss.h"
#include "test.h"
#include "abyss.h"
static void
bindSocketToPort(int const fd,
uint16_t const portNumber) {
struct sockaddr_in name;
int rc;
name.sin_family = AF_INET;
name.sin_port = htons(portNumber);
name.sin_addr.s_addr = INADDR_ANY;
rc = bind(fd, (struct sockaddr *)&name, sizeof(name));
if (rc != 0)
fprintf(stderr, "bind() of %d failed, errno=%d (%s)",
fd, errno, strerror(errno));
TEST(rc == 0);
}
static void
chanSwitchCreateFd(int const fd,
TChanSwitch ** const chanSwitchPP,
const char ** const errorP) {
#ifdef WIN32
ChanSwitchWinCreateWinsock(fd, chanSwitchPP, errorP);
#else
ChanSwitchUnixCreateFd(fd, chanSwitchPP, errorP);
#endif
}
static void
closesock(int const fd) {
#ifdef WIN32
closesocket(fd);
#else
close(fd);
#endif
}
static void
chanSwitchCreate(uint16_t const portNumber,
TChanSwitch ** const chanSwitchPP,
const char ** const errorP) {
#ifdef WIN32
ChanSwitchWinCreate(portNumber, chanSwitchPP, errorP);
#else
ChanSwitchUnixCreate(portNumber, chanSwitchPP, errorP);
#endif
}
static void
channelCreateFd(int const fd,
TChannel ** const channelPP,
const char ** const errorP) {
#ifdef WIN32
struct abyss_win_chaninfo * channelInfoP;
ChannelWinCreateWinsock(fd, channelPP, &channelInfoP, errorP);
#else
struct abyss_unix_chaninfo * channelInfoP;
ChannelUnixCreateFd(fd, channelPP, &channelInfoP, errorP);
#endif
}
static void
testChanSwitchOsSocket(void) {
int rc;
rc = socket(AF_INET, SOCK_STREAM, 0);
if (rc < 0) {
fprintf(stderr, "socket() failed with errno %d (%s)",
errno, strerror(errno));
abort();
} else {
int const fd = rc;
TChanSwitch * chanSwitchP;
TServer server;
const char * error;
bindSocketToPort(fd, 8080);
chanSwitchCreateFd(fd, &chanSwitchP, &error);
TEST_NULL_STRING(error);
ServerCreateSwitch(&server, chanSwitchP, &error);
TEST_NULL_STRING(error);
ServerFree(&server);
ChanSwitchDestroy(chanSwitchP);
closesock(fd);
}
}
static void
testChanSwitch(void) {
TServer server;
TChanSwitch * chanSwitchP;
const char * error;
chanSwitchCreate(8080, &chanSwitchP, &error);
TEST_NULL_STRING(error);
ServerCreateSwitch(&server, chanSwitchP, &error);
TEST_NULL_STRING(error);
ServerFree(&server);
ChanSwitchDestroy(chanSwitchP);
testChanSwitchOsSocket();
}
static void
testChannel(void) {
int rc;
rc = socket(AF_INET, SOCK_STREAM, 0);
if (rc < 0) {
fprintf(stderr, "socket() failed with errno %d (%s)",
errno, strerror(errno));
abort();
} else {
int const fd = rc;
TChannel * channelP;
const char * error;
channelCreateFd(fd, &channelP, &error);
TEST(error);
TEST(strstr(error, "not in connected"));
}
}
static void
testOsSocket(void) {
int rc;
rc = socket(AF_INET, SOCK_STREAM, 0);
if (rc < 0) {
fprintf(stderr, "socket() failed with errno %d (%s)",
errno, strerror(errno));
abort();
} else {
int const fd = rc;
TServer server;
abyss_bool success;
bindSocketToPort(fd, 8080);
success = ServerCreateSocket(&server, NULL, fd, NULL, NULL);
TEST(success);
ServerFree(&server);
closesock(fd);
}
}
static void
testSocket(void) {
#ifndef WIN32
int rc;
rc = socket(AF_INET, SOCK_STREAM, 0);
if (rc < 0) {
fprintf(stderr, "socket() failed with errno %d (%s)",
errno, strerror(errno));
abort();
} else {
int const fd = rc;
TSocket * socketP;
TServer server;
const char * error;
SocketUnixCreateFd(fd, &socketP);
TEST(socketP != NULL);
ServerCreateSocket2(&server, socketP, &error);
TEST(!error);
ServerFree(&server);
SocketDestroy(socketP);
close(fd);
}
#endif
}
static void
testServerCreate(void) {
TServer server;
abyss_bool success;
success = ServerCreate(&server, NULL, 8080, NULL, NULL);
TEST(success);
ServerInit(&server);
ServerFree(&server);
success = ServerCreate(&server, "myserver", 8080,
"/tmp/docroot", "/tmp/logfile");
TEST(success);
ServerInit(&server);
ServerFree(&server);
success = ServerCreateNoAccept(&server, NULL, NULL, NULL);
TEST(success);
ServerFree(&server);
{
TChanSwitch * chanSwitchP;
const char * error;
chanSwitchCreate(8080, &chanSwitchP, &error);
TEST_NULL_STRING(error);
ServerCreateSwitch(&server, chanSwitchP, &error);
TEST_NULL_STRING(error);
ServerSetName(&server, "/tmp/docroot");
ServerSetLogFileName(&server, "/tmp/logfile");
ServerSetKeepaliveTimeout(&server, 50);
ServerSetKeepaliveMaxConn(&server, 5);
ServerSetTimeout(&server, 75);
ServerSetAdvertise(&server, 1);
ServerSetAdvertise(&server, 0);
ServerInit(&server);
ServerFree(&server);
ChanSwitchDestroy(chanSwitchP);
}
}
void
test_abyss(void) {
const char * error;
printf("Running Abyss server tests...\n");
AbyssInit(&error);
TEST_NULL_STRING(error);
ChanSwitchInit(&error);
TEST_NULL_STRING(error);
ChannelInit(&error);
TEST_NULL_STRING(error);
testChanSwitch();
testChannel();
testOsSocket();
testSocket();
testServerCreate();
ChannelTerm();
ChanSwitchTerm();
AbyssTerm();
printf("\n");
printf("Abyss server tests done.\n");
}
+2
View File
@@ -0,0 +1,2 @@
void
test_abyss(void);
+5 -1
View File
@@ -21,6 +21,8 @@ static const char cgiResponse1[] =
"</methodResponse>\r\n";
#define TESTDATA_DIR "data"
#define DIRSEP DIRECTORY_SEPARATOR
void
test_server_cgi(void) {
@@ -36,7 +38,8 @@ test_server_cgi(void) {
"CONTENT_TYPE=text/xml "
"CONTENT_LENGTH=211 "
"./cgitest1 "
"<sample_add_call.xml",
"<"
TESTDATA_DIR DIRSEP "sample_add_call.xml",
"r");
if (cgiOutputP == NULL)
@@ -51,6 +54,7 @@ test_server_cgi(void) {
TEST(memcmp(cgiResponse, cgiResponse1, bytesRead) == 0);
}
fclose(cgiOutputP);
printf("\n");
printf("CGI tests done.\n");
}
+344 -11
View File
@@ -4,17 +4,285 @@
#include <errno.h>
#include "xmlrpc_config.h"
#include "transport_config.h"
#include "xmlrpc-c/base.h"
#include "xmlrpc-c/client.h"
#include "xmlrpc-c/transport.h"
#include "test.h"
#include "client.h"
static void
testGlobalConst(void) {
xmlrpc_env env;
xmlrpc_env_init(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_teardown_global_const();
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_teardown_global_const();
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
static void
test_init_cleanup(void) {
testCreateCurlParms(void) {
#if MUST_BUILD_CURL_CLIENT
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
xmlrpc_env_init(&env);
clientParms1.transport = "curl";
clientParms1.transportparmsP = &curlTransportParms1;
curlTransportParms1.network_interface = "eth0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(network_interface);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
curlTransportParms1.no_ssl_verifypeer = 1;
curlTransportParms1.no_ssl_verifyhost = 1;
clientParms1.transportparm_size = XMLRPC_CXPSIZE(no_ssl_verifyhost);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
curlTransportParms1.user_agent = "testprog/1.0";
clientParms1.transportparm_size = XMLRPC_CXPSIZE(user_agent);
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_env_clean(&env);
#endif /* MUST_BUILD_CURL_CLIENT */
}
static void
testCreateSeparateXport(void) {
#if MUST_BUILD_CURL_CLIENT
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
struct xmlrpc_client_transport * transportP;
xmlrpc_env_init(&env);
xmlrpc_curl_transport_ops.create(
&env, 0, "", "", &curlTransportParms1, 0,
&transportP);
TEST_NO_FAULT(&env);
clientParms1.transport = NULL;
clientParms1.transportparmsP = NULL;
clientParms1.transportparm_size = 0;
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_NO_FAULT(&env);
clientParms1.transport = "curl";
clientParms1.transportparmsP = &curlTransportParms1;
clientParms1.transportparm_size = 0;
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_NO_FAULT(&env);
clientParms1.transportP = transportP;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Both transportP and transport specified */
clientParms1.transport = NULL;
clientParms1.transportparmsP = NULL;
clientParms1.transportparm_size = 0;
clientParms1.transportOpsP = &xmlrpc_curl_transport_ops;
clientParms1.transportP = transportP;
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportOpsP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* transportOpsP but no transportP */
xmlrpc_client_create(&env, 0, "", "",
&clientParms1, XMLRPC_CPSIZE(transportP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_curl_transport_ops.destroy(transportP);
xmlrpc_env_clean(&env);
#endif /* MUST_BUILD_CURL_CLIENT */
}
static void
testCreateDestroy(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
struct xmlrpc_clientparms clientParms1;
struct xmlrpc_curl_xportparms curlTransportParms1;
int interrupt;
xmlrpc_env_init(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
/* Didn't set up global const */
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
xmlrpc_client_create(&env, 0, "testprog", "1.0", &clientParms1, 0,
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transport = "curl";
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transport), &clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportparmsP = NULL;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportOpsP = NULL;
clientParms1.transportP = NULL;
clientParms1.dialect = xmlrpc_dialect_apache;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(dialect),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_destroy(clientP);
clientParms1.transportparmsP = &curlTransportParms1;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP),
&clientP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
clientParms1.transportparm_size = 0;
xmlrpc_client_create(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size),
&clientP);
TEST_NO_FAULT(&env);
xmlrpc_client_set_interrupt(clientP, &interrupt);
xmlrpc_client_set_interrupt(clientP, NULL);
xmlrpc_client_destroy(clientP);
testCreateCurlParms();
testCreateSeparateXport();
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
static void
testSynchCall(void) {
xmlrpc_env env;
xmlrpc_client * clientP;
xmlrpc_value * resultP;
xmlrpc_value * emptyArrayP;
xmlrpc_server_info * noSuchServerInfoP;
xmlrpc_env_init(&env);
emptyArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_setup_global_const(&env);
TEST_NO_FAULT(&env);
xmlrpc_client_create(&env, 0, "testprog", "1.0", NULL, 0, &clientP);
TEST_NO_FAULT(&env);
noSuchServerInfoP = xmlrpc_server_info_new(&env, "nosuchserver");
TEST_NO_FAULT(&env);
xmlrpc_client_call2(&env, clientP, noSuchServerInfoP, "nosuchmethod",
emptyArrayP, &resultP);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_client_call2f(&env, clientP, "nosuchserver", "nosuchmethod",
&resultP, "(i)", 7);
TEST_FAULT(&env, XMLRPC_NETWORK_ERROR); /* No such server */
xmlrpc_server_info_free(noSuchServerInfoP);
xmlrpc_client_destroy(clientP);
xmlrpc_DECREF(emptyArrayP);
xmlrpc_client_teardown_global_const();
xmlrpc_env_clean(&env);
}
static void
testInitCleanup(void) {
xmlrpc_env env;
struct xmlrpc_clientparms clientParms1;
@@ -42,15 +310,13 @@ test_init_cleanup(void) {
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
clientParms1.transportparmsP = (struct xmlrpc_xportparms *)
&curlTransportParms1;
{
xmlrpc_env env2;
xmlrpc_env_init(&env2);
xmlrpc_client_init2(&env2, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP));
TEST_FAULT(&env2, XMLRPC_INTERNAL_ERROR);
}
clientParms1.transportparmsP = &curlTransportParms1;
/* Fails because we didn't include transportparm_size: */
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparmsP));
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
clientParms1.transportparm_size = 0;
xmlrpc_client_init2(&env, 0, "testprog", "1.0",
&clientParms1, XMLRPC_CPSIZE(transportparm_size));
@@ -82,6 +348,69 @@ test_init_cleanup(void) {
xmlrpc_client_init(0, "testprog", "1.0");
TEST_NO_FAULT(&env);
xmlrpc_client_cleanup();
xmlrpc_env_clean(&env);
}
static void
testServerInfo(void) {
xmlrpc_env env;
xmlrpc_server_info * serverInfoP;
xmlrpc_server_info * serverInfo2P;
printf(" Running serverInfo tests...\n");
xmlrpc_env_init(&env);
serverInfoP = xmlrpc_server_info_new(&env, "testurl");
TEST_NO_FAULT(&env);
serverInfo2P = xmlrpc_server_info_copy(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_free(serverInfo2P);
/* Fails because we haven't set user/password yet: */
xmlrpc_server_info_allow_auth_basic(&env, serverInfoP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_server_info_set_basic_auth(&env, serverInfoP,
"username", "password");
TEST_NO_FAULT(&env);
xmlrpc_server_info_set_user(&env, serverInfoP, "username", "password");
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_basic(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_basic(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_digest(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_digest(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_negotiate(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_negotiate(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_allow_auth_ntlm(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_disallow_auth_ntlm(&env, serverInfoP);
TEST_NO_FAULT(&env);
xmlrpc_server_info_free(serverInfoP);
xmlrpc_env_clean(&env);
}
@@ -91,7 +420,11 @@ test_client(void) {
printf("Running client tests.");
test_init_cleanup();
testGlobalConst();
testCreateDestroy();
testInitCleanup();
testServerInfo();
testSynchCall();
printf("\n");
printf("Client tests done.\n");
+14
View File
@@ -0,0 +1,14 @@
#include <stdio.h>
#include "client.h"
void
test_client(void) {
printf("Running dummy client test.");
printf("\n");
printf("Client tests done.\n");
}
@@ -0,0 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- This may or may not be legal XML-RPC, but some old clients (including
Ruby and xmlrpc-epi) send it. This should be interpreted as a call with no
parameters. -->
<methodCall>
<methodName>foo</methodName>
</methodCall>
@@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<methodCall>
<params>
<param>
<value><int>2</int></value>
</param>
<param>
<value><int>2</int></value>
</param>
</params>
<methodName>add</methodName>
</methodCall>
@@ -0,0 +1,14 @@
<?xml version="1.0" encoding="UTF-8"?>
<methodCall>
<methodName>foo</methodName>
<params>
<param>
<value><struct>
<member>
<value><i4>0</i4></value>
<name>child elements reversed!</name>
</member>
</struct></value>
</param>
</params>
</methodCall>
@@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<methodCall>
<methodName>sample.add</methodName>
<params>
<param><value><i4>5</i4></value></param>
<param><value><i4>7</i4></value></param>
</params>
</methodCall>
+951
View File
@@ -0,0 +1,951 @@
#include <stdlib.h>
#include <string.h>
#include "int.h"
#include "casprintf.h"
#include "girstring.h"
#include "xmlrpc_config.h"
#include "xmlrpc-c/base.h"
#include "xmlrpc-c/server.h"
#include "test.h"
#include "xml_data.h"
#include "method_registry.h"
#define FOO_SERVERINFO ((void*) 0xF00)
#define FOO_CALLINFO ((void*) 0xFC0)
#define BAR_SERVERINFO ((void*) 0xBAF)
#define BAR_CALLINFO ((void*) 0xBAC)
#define MULTI_CALLINFO ((void*) 0xFFF)
#define DEFAULT_SERVERINFO ((void*) 0xD00)
#define DEFAULT_CALLINFO ((void*) 0xDC0)
static const char * const barHelp = "This is the help for Method test.bar.";
static xmlrpc_value *
test_foo(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo,
void * const callInfo) {
xmlrpc_int32 x, y;
TEST_NO_FAULT(envP);
TEST(paramArrayP != NULL);
TEST(serverInfo == FOO_SERVERINFO);
TEST(callInfo == FOO_CALLINFO || callInfo == MULTI_CALLINFO);
xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);
TEST_NO_FAULT(envP);
TEST(x == 25);
TEST(y == 17);
return xmlrpc_build_value(envP, "i", (xmlrpc_int32) x + y);
}
static xmlrpc_value *
test_foo_type1(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo) {
xmlrpc_int32 x, y;
TEST_NO_FAULT(envP);
TEST(paramArrayP != NULL);
TEST(serverInfo == FOO_SERVERINFO);
xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);
TEST_NO_FAULT(envP);
TEST(x == 25);
TEST(y == 17);
return xmlrpc_build_value(envP, "i", (xmlrpc_int32) x + y);
}
static xmlrpc_value *
test_bar(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP,
void * const serverInfo,
void * const callInfo) {
xmlrpc_int32 x, y;
TEST_NO_FAULT(envP);
TEST(paramArrayP != NULL);
TEST(serverInfo == BAR_SERVERINFO);
TEST(callInfo == BAR_CALLINFO || callInfo == MULTI_CALLINFO);
xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);
TEST_NO_FAULT(envP);
TEST(x == 25);
TEST(y == 17);
xmlrpc_env_set_fault(envP, 123, "Test fault");
return NULL;
}
static xmlrpc_value *
test_default(xmlrpc_env * const envP,
const char * const callInfo,
const char * const methodName,
xmlrpc_value * const paramArrayP,
void * const serverInfo) {
xmlrpc_int32 x, y;
TEST_NO_FAULT(envP);
TEST(paramArrayP != NULL);
TEST(serverInfo == DEFAULT_SERVERINFO);
TEST(streq(methodName, "test.nosuch") ||
streq(methodName, "test.nosuch.old"));
if (streq(methodName, "nosuch.method"))
TEST(callInfo == DEFAULT_CALLINFO);
else if (streq(methodName, "nosuch.method.old"))
TEST(callInfo == NULL);
xmlrpc_decompose_value(envP, paramArrayP, "(ii)", &x, &y);
TEST_NO_FAULT(envP);
TEST(x == 25);
TEST(y == 17);
return xmlrpc_build_value(envP, "i", 2 * (x + y));
}
static xmlrpc_value *
test_exttype(xmlrpc_env * const envP,
xmlrpc_value * const paramArrayP ATTR_UNUSED,
void * const serverInfo ATTR_UNUSED,
void * const callInfo ATTR_UNUSED) {
return xmlrpc_build_value(envP, "(In)", (xmlrpc_int64)8);
}
static void
doRpc(xmlrpc_env * const envP,
xmlrpc_registry * const registryP,
const char * const methodName,
xmlrpc_value * const argArrayP,
void * const callInfo,
xmlrpc_value ** const resultPP) {
/*----------------------------------------------------------------------------
Do what an XML-RPC server would do -- pass an XML call to the registry
and get XML back.
Actually to our caller, we look more like an Xmlrpc-c client. We're
both the client and the server all bound together.
-----------------------------------------------------------------------------*/
xmlrpc_mem_block * callP;
xmlrpc_mem_block * responseP;
/* Build a call, and tell the registry to handle it. */
callP = xmlrpc_mem_block_new(envP, 0);
TEST_NO_FAULT(envP);
xmlrpc_serialize_call(envP, callP, methodName, argArrayP);
TEST_NO_FAULT(envP);
if (callInfo)
xmlrpc_registry_process_call2(
envP, registryP,
xmlrpc_mem_block_contents(callP),
xmlrpc_mem_block_size(callP),
callInfo, &responseP);
else
responseP = xmlrpc_registry_process_call(
envP, registryP, NULL,
xmlrpc_mem_block_contents(callP),
xmlrpc_mem_block_size(callP));
TEST_NO_FAULT(envP);
TEST(responseP != NULL);
/* Parse the response. */
*resultPP = xmlrpc_parse_response(envP,
xmlrpc_mem_block_contents(responseP),
xmlrpc_mem_block_size(responseP));
xmlrpc_mem_block_free(callP);
xmlrpc_mem_block_free(responseP);
}
static const char * const validSigString[] = {
"i:",
"s:d",
"i:bds86SA",
"i:,i:",
"i:dd,s:,A:A",
"i:,",
"b:i,",
"b:i,b:,",
NULL
};
static const char * const invalidSigString[] = {
"",
"i",
"q",
"i:q",
"i:ddq",
",",
",i:",
"i,",
"b:i,,b:i",
"ii:",
"ii:ii",
NULL
};
static void
test_system_methodSignature(xmlrpc_registry * const registryP) {
/*----------------------------------------------------------------------------
Test system.methodSignature system method.
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * argArrayP;
xmlrpc_value * resultP;
const char * type0;
const char * type1;
const char * type2;
const char * type3;
const char * type4;
const char * type5;
const char * type6;
const char * type7;
const char * nosigstring;
xmlrpc_env_init(&env);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.nosuchmethod");
doRpc(&env, registryP, "system.methodSignature", argArrayP, NULL,
&resultP);
TEST_FAULT(&env, XMLRPC_NO_SUCH_METHOD_ERROR);
xmlrpc_DECREF(argArrayP);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.nosig0");
doRpc(&env, registryP, "system.methodSignature", argArrayP, NULL,
&resultP);
TEST_NO_FAULT(&env);
xmlrpc_read_string(&env, resultP, &nosigstring);
TEST_NO_FAULT(&env);
TEST(streq(nosigstring, "undef"));
strfree(nosigstring);
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.validsig0");
doRpc(&env, registryP, "system.methodSignature", argArrayP, NULL,
&resultP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, resultP, "((s))", &type0);
TEST_NO_FAULT(&env);
TEST(streq(type0, "int"));
strfree(type0);
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.validsig2");
doRpc(&env, registryP, "system.methodSignature", argArrayP, NULL,
&resultP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, resultP, "((ssssssss))",
&type0, &type1, &type2, &type3,
&type4, &type5, &type6, &type7);
TEST_NO_FAULT(&env);
TEST(streq(type0, "int"));
TEST(streq(type1, "boolean"));
TEST(streq(type2, "double"));
TEST(streq(type3, "string"));
TEST(streq(type4, "dateTime.iso8601"));
TEST(streq(type5, "base64"));
TEST(streq(type6, "struct"));
TEST(streq(type7, "array"));
strfree(type0); strfree(type1); strfree(type2); strfree(type3);
strfree(type4); strfree(type5); strfree(type6); strfree(type7);
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.validsig3");
doRpc(&env, registryP, "system.methodSignature", argArrayP, NULL,
&resultP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, resultP, "((s)(s))", &type0, &type1);
TEST_NO_FAULT(&env);
TEST(streq(type0, "int"));
TEST(streq(type1, "int"));
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
}
static void
test_signature(void) {
xmlrpc_env env;
xmlrpc_registry * registryP;
uint i;
xmlrpc_env_init(&env);
printf(" Running signature tests.");
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method2(&env, registryP, "test.nosig0",
test_foo, NULL, NULL, FOO_SERVERINFO);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method2(&env, registryP, "test.nosig1",
test_foo, "?", NULL, FOO_SERVERINFO);
TEST_NO_FAULT(&env);
for (i = 0; validSigString[i]; ++i) {
const char * methodName;
casprintf(&methodName, "test.validsig%u", i);
xmlrpc_registry_add_method2(&env, registryP, methodName,
test_foo,
validSigString[i], NULL, FOO_SERVERINFO);
TEST_NO_FAULT(&env);
strfree(methodName);
}
for (i = 0; invalidSigString[i]; ++i) {
const char * methodName;
casprintf(&methodName, "test.invalidsig%u", i);
xmlrpc_registry_add_method2(&env, registryP, methodName,
test_foo,
invalidSigString[i], NULL, FOO_SERVERINFO);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
strfree(methodName);
}
xmlrpc_registry_add_method_w_doc(&env, registryP, NULL, "test.old",
test_foo_type1, FOO_SERVERINFO,
NULL, NULL);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method_w_doc(&env, registryP, NULL, "test.old.invalid",
test_foo_type1, FOO_SERVERINFO,
invalidSigString[0], NULL);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
test_system_methodSignature(registryP);
xmlrpc_registry_free(registryP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
test_disable_introspection(void) {
xmlrpc_env env;
xmlrpc_registry * registryP;
xmlrpc_value * argArrayP;
xmlrpc_value * resultP;
xmlrpc_env_init(&env);
printf(" Running disable introspection tests.");
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method2(&env, registryP, "test.nosig0",
test_foo, NULL, NULL, FOO_SERVERINFO);
TEST_NO_FAULT(&env);
xmlrpc_registry_disable_introspection(registryP);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.nosig0");
doRpc(&env, registryP, "system.methodSignature", argArrayP, NULL,
&resultP);
TEST_FAULT(&env, XMLRPC_INTROSPECTION_DISABLED_ERROR);
xmlrpc_DECREF(argArrayP);
xmlrpc_registry_free(registryP);
xmlrpc_env_clean(&env);
printf("\n");
}
static const char * const expectedMethodName[] = {
/*----------------------------------------------------------------------------
The list we expect back from system.listMethods.
-----------------------------------------------------------------------------*/
"system.listMethods",
"system.methodSignature",
"system.methodHelp",
"system.multicall",
"system.shutdown",
"system.capabilities",
"test.foo",
"test.bar"
};
static void
test_system_listMethods(xmlrpc_registry * const registryP) {
/*----------------------------------------------------------------------------
Test system.listMethods
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_value * argArrayP;
const char * methodName[8];
unsigned int size;
unsigned int i;
xmlrpc_env_init(&env);
printf(" Running system.listMethods tests.");
argArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.listMethods", argArrayP, NULL, &resultP);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(resultP) == XMLRPC_TYPE_ARRAY);
size = xmlrpc_array_size(&env, resultP);
TEST_NO_FAULT(&env);
TEST(size == ARRAY_SIZE(expectedMethodName));
xmlrpc_decompose_value(&env, resultP, "(ssssssss)",
&methodName[0], &methodName[1],
&methodName[2], &methodName[3],
&methodName[4], &methodName[5],
&methodName[6], &methodName[7]);
for (i = 0; i < ARRAY_SIZE(methodName); ++i) {
TEST(streq(methodName[i], expectedMethodName[i]));
strfree(methodName[i]);
}
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
test_system_methodHelp(xmlrpc_registry * const registryP) {
/*----------------------------------------------------------------------------
Test system.methodHelp
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_value * argArrayP;
const char * helpString;
xmlrpc_env_init(&env);
printf(" Running system.methodHelp tests.");
argArrayP = xmlrpc_build_value(&env, "(s)", "test.foo");
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.methodHelp", argArrayP, NULL, &resultP);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(resultP) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, resultP, &helpString);
TEST_NO_FAULT(&env);
TEST(streq(helpString, "No help is available for this method."));
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
argArrayP = xmlrpc_build_value(&env, "(s)", "test.bar");
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.methodHelp", argArrayP, NULL, &resultP);
TEST_NO_FAULT(&env);
TEST(xmlrpc_value_type(resultP) == XMLRPC_TYPE_STRING);
xmlrpc_read_string(&env, resultP, &helpString);
TEST_NO_FAULT(&env);
TEST(streq(helpString, barHelp));
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
test_system_capabilities(xmlrpc_registry * const registryP) {
/*----------------------------------------------------------------------------
Test system.capabilities
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_value * argArrayP;
const char * facility;
xmlrpc_int version_major, version_minor, version_point;
xmlrpc_int protocol_version;
xmlrpc_env_init(&env);
printf(" Running system.capabilities tests.");
argArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.capabilities", argArrayP, NULL, &resultP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, resultP, "{s:s,s:i,s:i,s:i,s:i,*}",
"facility", &facility,
"version_major", &version_major,
"version_minor", &version_minor,
"version_point", &version_point,
"protocol_version", &protocol_version);
TEST_NO_FAULT(&env);
TEST(streq(facility, "xmlrpc-c"));
TEST(protocol_version == 2);
xmlrpc_DECREF(resultP);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
test_system_multicall(xmlrpc_registry * const registryP) {
/*----------------------------------------------------------------------------
Test system.multicall
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * multiP;
xmlrpc_int32 foo1_result, foo2_result;
xmlrpc_int32 bar_code, nosuch_code;
char *bar_string, *nosuch_string;
xmlrpc_value * valueP;
xmlrpc_value * argArrayP;
xmlrpc_env_init(&env);
printf(" Running multicall tests.");
/* Build an argument array for our calls. */
argArrayP = xmlrpc_build_value(&env, "(ii)",
(xmlrpc_int32) 25, (xmlrpc_int32) 17);
TEST_NO_FAULT(&env);
multiP = xmlrpc_build_value(&env,
"(("
"{s:s,s:A}" /* test.foo */
"{s:s,s:A}" /* test.bar */
"{s:s,s:A}" /* test.nosuch */
"{s:s,s:A}" /* test.foo */
"))",
"methodName", "test.foo",
"params", argArrayP,
"methodName", "test.bar",
"params", argArrayP,
"methodName", "test.nosuch",
"params", argArrayP,
"methodName", "test.foo",
"params", argArrayP);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.multicall", multiP, MULTI_CALLINFO,
&valueP);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, valueP,
"("
"(i)" /* result of test.foo */
"{s:i,s:s,*}" /* result of test.bar */
"{s:i,s:s,*}" /* result of test.nosuch */
"(i)" /* result of test.foo #2 */
")",
&foo1_result,
"faultCode", &bar_code,
"faultString", &bar_string,
"faultCode", &nosuch_code,
"faultString", &nosuch_string,
&foo2_result);
xmlrpc_DECREF(valueP);
TEST_NO_FAULT(&env);
TEST(foo1_result == 42);
TEST(bar_code == 123);
TEST(strcmp(bar_string, "Test fault") == 0);
TEST(nosuch_code == XMLRPC_NO_SUCH_METHOD_ERROR);
TEST(foo2_result == 42);
xmlrpc_DECREF(multiP);
free(bar_string);
/* Now for some invalid multi calls */
multiP = xmlrpc_build_value(&env,
"(({s:s,s:V}{s:s,s:()}{s:s,s:V}))",
"methodName", "test.foo",
"params", argArrayP,
"methodName", "system.multicall",
"params",
"methodName", "test.foo",
"params", argArrayP);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.multicall", multiP, MULTI_CALLINFO,
&valueP);
TEST_FAULT(&env, XMLRPC_REQUEST_REFUSED_ERROR);
xmlrpc_DECREF(multiP);
multiP = xmlrpc_build_value(&env,
"(({s:s,s:V}d))",
"methodName", "test.foo",
"params", argArrayP,
5.0);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.multicall", multiP, MULTI_CALLINFO,
&valueP);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_DECREF(multiP);
multiP = xmlrpc_build_value(&env,
"({s:s,s:V})",
"methodName", "test.foo",
"params", argArrayP);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.multicall", multiP, MULTI_CALLINFO,
&valueP);
TEST_FAULT(&env, XMLRPC_TYPE_ERROR);
xmlrpc_DECREF(multiP);
multiP = xmlrpc_build_value(&env, "(({}))");
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.multicall", multiP, MULTI_CALLINFO,
&valueP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_DECREF(multiP);
multiP = xmlrpc_build_value(&env, "(({s:s}))",
"methodName", "test.foo");
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "system.multicall", multiP, MULTI_CALLINFO,
&valueP);
TEST_FAULT(&env, XMLRPC_INDEX_ERROR);
xmlrpc_DECREF(multiP);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
testCall(xmlrpc_registry * const registryP) {
xmlrpc_env env;
xmlrpc_env env2;
xmlrpc_value * argArrayP;
xmlrpc_value * valueP;
xmlrpc_int32 i;
printf(" Running call tests.");
xmlrpc_env_init(&env);
/* Build an argument array for our calls. */
argArrayP = xmlrpc_build_value(&env, "(ii)",
(xmlrpc_int32) 25, (xmlrpc_int32) 17);
TEST_NO_FAULT(&env);
/* Call test.foo and check the result. */
doRpc(&env, registryP, "test.foo", argArrayP, FOO_CALLINFO, &valueP);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
xmlrpc_decompose_value(&env, valueP, "i", &i);
xmlrpc_DECREF(valueP);
TEST_NO_FAULT(&env);
TEST(i == 42);
/* Call test.bar and check the result. */
xmlrpc_env_init(&env2);
doRpc(&env2, registryP, "test.bar", argArrayP, BAR_CALLINFO, &valueP);
TEST(env2.fault_occurred);
TEST(env2.fault_code == 123);
TEST(env2.fault_string && strcmp(env2.fault_string, "Test fault") == 0);
xmlrpc_env_clean(&env2);
/* Call a non-existant method and check the result. */
xmlrpc_env_init(&env2);
doRpc(&env2, registryP, "test.nosuch", argArrayP, FOO_CALLINFO, &valueP);
TEST(valueP == NULL);
TEST_FAULT(&env2, XMLRPC_NO_SUCH_METHOD_ERROR);
xmlrpc_env_clean(&env2);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
testDefaultMethod(xmlrpc_registry * const registryP) {
xmlrpc_env env;
xmlrpc_value * argArrayP;
xmlrpc_value * valueP;
xmlrpc_int32 i;
xmlrpc_env_init(&env);
printf(" Running default method tests.");
/* Build an argument array for our calls. */
argArrayP = xmlrpc_build_value(&env, "(ii)",
(xmlrpc_int32) 25, (xmlrpc_int32) 17);
xmlrpc_registry_set_default_method(&env, registryP, &test_default,
DEFAULT_SERVERINFO);
TEST_NO_FAULT(&env);
doRpc(&env, registryP, "test.nosuch", argArrayP, DEFAULT_CALLINFO,
&valueP);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
xmlrpc_decompose_value(&env, valueP, "i", &i);
xmlrpc_DECREF(valueP);
TEST_NO_FAULT(&env);
TEST(i == 84);
/* Now try it with old method interface */
doRpc(&env, registryP, "test.nosuch.old", argArrayP, NULL, &valueP);
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
xmlrpc_read_int(&env, valueP, &i);
TEST_NO_FAULT(&env);
xmlrpc_DECREF(valueP);
TEST(i == 84);
/* Change the default method. */
xmlrpc_registry_set_default_method(&env, registryP, &test_default,
BAR_SERVERINFO);
TEST_NO_FAULT(&env);
xmlrpc_DECREF(argArrayP);
xmlrpc_env_clean(&env);
printf("\n");
}
static void
test_apache_dialect(void) {
char const expectedResp[] =
XML_PROLOGUE
"<methodResponse>\r\n"
"<params>\r\n"
"<param><value><array><data>\r\n"
"<value><ex.i8>8</ex.i8></value>\r\n"
"<value><ex.nil/></value>\r\n"
"</data></array></value></param>\r\n"
"</params>\r\n"
"</methodResponse>\r\n";
xmlrpc_env env;
xmlrpc_registry * registryP;
xmlrpc_value * argArrayP;
xmlrpc_mem_block * callP;
xmlrpc_mem_block * responseP;
xmlrpc_env_init(&env);
printf(" Running apache dialect tests.");
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
xmlrpc_registry_set_dialect(&env, registryP, xmlrpc_dialect_i8);
TEST_NO_FAULT(&env);
xmlrpc_registry_set_dialect(&env, registryP, 100);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR);
xmlrpc_registry_set_dialect(&env, registryP, xmlrpc_dialect_apache);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method2(&env, registryP, "test_exttype",
test_exttype, NULL, NULL, FOO_SERVERINFO);
TEST_NO_FAULT(&env);
argArrayP = xmlrpc_array_new(&env);
TEST_NO_FAULT(&env);
callP = xmlrpc_mem_block_new(&env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_call(&env, callP, "test_exttype", argArrayP);
TEST_NO_FAULT(&env);
xmlrpc_registry_process_call2(
&env, registryP,
xmlrpc_mem_block_contents(callP),
xmlrpc_mem_block_size(callP),
NULL, &responseP);
TEST_NO_FAULT(&env);
TEST(XMLRPC_MEMBLOCK_SIZE(char, responseP) == strlen(expectedResp));
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, responseP),
expectedResp,
XMLRPC_MEMBLOCK_SIZE(char, responseP)));
xmlrpc_DECREF(argArrayP);
xmlrpc_mem_block_free(callP);
xmlrpc_mem_block_free(responseP);
xmlrpc_registry_free(registryP);
xmlrpc_env_clean(&env);
printf("\n");
}
void
test_method_registry(void) {
xmlrpc_env env, env2;
xmlrpc_value * valueP;
xmlrpc_registry * registryP;
xmlrpc_mem_block * responseP;
xmlrpc_env_init(&env);
printf("Running method registry tests.");
/* Create a new registry. */
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
TEST(registryP != NULL);
/* Add some test methods. */
xmlrpc_registry_add_method(&env, registryP, NULL, "test.foo",
test_foo_type1, FOO_SERVERINFO);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method2(&env, registryP, "test.bar",
test_bar, NULL, barHelp, BAR_SERVERINFO);
TEST_NO_FAULT(&env);
printf("\n");
testCall(registryP);
test_system_multicall(registryP);
xmlrpc_env_init(&env2);
xmlrpc_registry_process_call2(&env, registryP,
expat_error_data,
strlen(expat_error_data),
NULL,
&responseP);
TEST_NO_FAULT(&env);
TEST(responseP != NULL);
valueP = xmlrpc_parse_response(&env2, xmlrpc_mem_block_contents(responseP),
xmlrpc_mem_block_size(responseP));
TEST(valueP == NULL);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
xmlrpc_mem_block_free(responseP);
xmlrpc_env_clean(&env2);
printf("\n");
testDefaultMethod(registryP);
test_system_listMethods(registryP);
test_system_methodHelp(registryP);
test_system_capabilities(registryP);
test_signature();
test_disable_introspection();
test_apache_dialect();
/* Test cleanup code (w/memprof). */
xmlrpc_registry_free(registryP);
printf("\n");
xmlrpc_env_clean(&env);
}
+7
View File
@@ -0,0 +1,7 @@
#ifndef TEST_METHOD_REGISTRY_H_INCLUDED
#define TEST_METHOD_REGISTRY_H_INCLUDED
void
test_method_registry(void);
#endif
+410 -144
View File
@@ -3,6 +3,8 @@
#include "xmlrpc_config.h"
#include "girstring.h"
#include "casprintf.h"
#include "xmlrpc-c/base.h"
#include "xmlrpc-c/xmlparser.h"
@@ -22,24 +24,24 @@ static void test_expat (void)
xmlrpc_env_init(&env);
/* Parse a moderately complex XML document. */
elem = xml_parse(&env, expat_data, strlen(expat_data));
xml_parse(&env, expat_data, strlen(expat_data), &elem);
TEST_NO_FAULT(&env);
TEST(elem != NULL);
/* Verify our results. */
TEST(strcmp(xml_element_name(elem), "value") == 0);
TEST(streq(xml_element_name(elem), "value"));
TEST(xml_element_children_size(elem) == 1);
array = xml_element_children(elem)[0];
TEST(strcmp(xml_element_name(array), "array") == 0);
TEST(streq(xml_element_name(array), "array"));
TEST(xml_element_children_size(array) == 1);
data = xml_element_children(array)[0];
TEST(strcmp(xml_element_name(data), "data") == 0);
TEST(streq(xml_element_name(data), "data"));
TEST(xml_element_children_size(data) > 1);
value1 = xml_element_children(data)[0];
TEST(strcmp(xml_element_name(value1), "value") == 0);
TEST(streq(xml_element_name(value1), "value"));
TEST(xml_element_children_size(value1) == 1);
i4 = xml_element_children(value1)[0];
TEST(strcmp(xml_element_name(i4), "i4") == 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);
@@ -49,11 +51,9 @@ static void test_expat (void)
/* Test cleanup code (w/memprof). */
xml_element_free(elem);
/* Try to parse broken XML. We want to know that a proper error occurs,
** AND that we don't leak any memory (w/memprof). */
elem = xml_parse(&env, expat_error_data, strlen(expat_error_data));
/* Test broken XML */
xml_parse(&env, expat_error_data, strlen(expat_error_data), &elem);
TEST(env.fault_occurred);
TEST(elem == NULL);
xmlrpc_env_clean(&env);
}
@@ -61,180 +61,444 @@ static void test_expat (void)
static void
test_parse_xml_value(void) {
testParseNumberValue(void) {
xmlrpc_env env, env2;
xmlrpc_value *s, *sval;
xmlrpc_int32 int_max, int_min, int_one;
xmlrpc_bool bool_false, bool_true;
char *str_hello, *str_untagged, *datetime;
unsigned char *b64_data;
size_t b64_len;
double negone, zero, one;
int size, sval_int;
const char **bad_value;
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, &paramArrayP);
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
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><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_value * valueP;
xmlrpc_env env;
xmlrpc_value * paramArrayP;
const char * methodName;
int arraySize;
const char * str_hello;
xmlrpc_bool b_false, b_true;
const char * datetime;
unsigned char * b64_data;
size_t b64_len;
/* Parse a correctly-formed response. */
valueP = xmlrpc_parse_response(&env, correct_value,
strlen(correct_value));
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
/* Analyze it and make sure it contains the correct values. */
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);
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, xmldata, strlen(xmldata),
&methodName, &paramArrayP);
TEST_NO_FAULT(&env);
arraySize = xmlrpc_array_size(&env, paramArrayP);
TEST_NO_FAULT(&env);
TEST(arraySize == 7);
xmlrpc_decompose_value(
&env, paramArrayP, "(sbb86nn)",
&str_hello, &b_false, &b_true, &datetime, &b64_data, &b64_len);
TEST_NO_FAULT(&env);
TEST(streq(str_hello, "hello"));
TEST(!b_false);
TEST(b_true);
TEST(streq(datetime, "19980717T14:08:55"));
TEST(b64_len == 11);
TEST(memcmp(b64_data, "base64 data", b64_len) == 0);
free(b64_data);
strfree(str_hello);
strfree(datetime);
xmlrpc_DECREF(paramArrayP);
strfree(methodName);
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);
xmlrpc_DECREF(valueP);
}
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(strcmp(str_hello, "Hello, world! <&>") == 0);
TEST(streq(str_hello, "Hello, world! <&>"));
TEST(b64_len == 11);
TEST(memcmp(b64_data, "base64 data", b64_len) == 0);
TEST(strcmp(datetime, "19980717T14:08:55") == 0);
TEST(streq(datetime, "19980717T14:08:55"));
TEST(int_one == 1);
TEST(negone == -1.0);
TEST(zero == 0.0);
TEST(one == 1.0);
TEST(strcmp(str_untagged, "Untagged string") == 0);
TEST(streq(str_untagged, "Untagged string"));
free(str_hello);
free(b64_data);
free(datetime);
free(str_untagged);
/* Analyze the contents of our struct. */
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);
/* Test our error-checking code. This is exposed to potentially-malicious
** network data, so we need to handle evil data gracefully, without
** barfing or leaking memory. (w/memprof) */
{
xmlrpc_value * valueP;
/* First, test some poorly-formed XML data. */
xmlrpc_env_init(&env2);
valueP = xmlrpc_parse_response(&env2, unparseable_value,
strlen(unparseable_value));
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
TEST(valueP == NULL);
xmlrpc_env_clean(&env2);
}
/* Next, check for bogus values. These are all well-formed XML, but
{
/* 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
testParseGoodResponse(void) {
xmlrpc_env env;
xmlrpc_value * valueP;
int faultCode;
const char * faultString;
xmlrpc_env_init(&env);
xmlrpc_parse_response2(&env, good_response_xml, strlen(good_response_xml),
&valueP, &faultCode, &faultString);
TEST_NO_FAULT(&env);
TEST(faultString == NULL);
validateParseResponseResult(valueP);
xmlrpc_DECREF(valueP);
/* Try it again with old interface */
valueP = xmlrpc_parse_response(&env,
good_response_xml,
strlen(good_response_xml));
TEST_NO_FAULT(&env);
TEST(valueP != NULL);
validateParseResponseResult(valueP);
xmlrpc_DECREF(valueP);
xmlrpc_env_clean(&env);
}
static void
testParseBadResponseXml(void) {
/*----------------------------------------------------------------------------
Test parsing of data that is supposed to be a response, but in not
even valid XML.
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_value * valueP;
int faultCode;
const char * faultString;
xmlrpc_env_init(&env);
xmlrpc_parse_response2(&env,
unparseable_value, strlen(unparseable_value),
&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, unparseable_value,
strlen(unparseable_value));
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env);
TEST(valueP == NULL);
}
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 (bad_value = bad_values; *bad_value != NULL; bad_value++) {
xmlrpc_value * valueP;
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!) */
elem = xml_parse(&env, *bad_value, strlen(*bad_value));
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_env_init(&env2);
valueP = xmlrpc_parse_response(&env2, *bad_value, strlen(*bad_value));
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
TEST(valueP == NULL);
xmlrpc_env_clean(&env2);
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
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_clean(&env);
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 test_parse_xml_response (void)
{
xmlrpc_env env, env2;
int i1;
const char **bad_resp;
static void
testParseBadResponse(void) {
/*----------------------------------------------------------------------------
Test parsing of data that is supposed to be a response, but is not
valid. Either not valid XML or not valid XML-RPC.
-----------------------------------------------------------------------------*/
testParseBadResponseXml();
testParseBadResponseXmlRpc();
testParseBadResult();
}
static void
testParseFaultResponse(void) {
/*----------------------------------------------------------------------------
Test parsing of a valid response that indicates the RPC failed.
-----------------------------------------------------------------------------*/
xmlrpc_env env;
xmlrpc_env_init(&env);
{
xmlrpc_value * v;
/* Parse a valid response. */
v = xmlrpc_parse_response(&env, serialized_response,
strlen(serialized_response));
TEST_NO_FAULT(&env);
TEST(v != NULL);
xmlrpc_decompose_value(&env, v, "i", &i1);
xmlrpc_DECREF(v);
}
TEST_NO_FAULT(&env);
TEST(i1 == 30);
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 * v;
xmlrpc_value * valueP;
xmlrpc_env fault;
/* Parse a valid fault. */
xmlrpc_env_init(&fault);
v = xmlrpc_parse_response(&fault, serialized_fault,
strlen(serialized_fault));
valueP = xmlrpc_parse_response(&fault, serialized_fault,
strlen(serialized_fault));
TEST(fault.fault_occurred);
TEST(fault.fault_code == 6);
TEST(strcmp(fault.fault_string, "A fault occurred") == 0);
TEST(streq(fault.fault_string, "A fault occurred"));
xmlrpc_env_clean(&fault);
}
/* We don't need to test our handling of poorly formatted XML here,
** because we already did that in test_parse_xml_value. */
/* Next, check for bogus responses. These are all well-formed XML, but
** they aren't legal XML-RPC. */
for (bad_resp = bad_responses; *bad_resp != NULL; bad_resp++) {
xmlrpc_value * v;
xml_element *elem;
/* First, check to make sure that our test case is well-formed XML.
** (It's easy to make mistakes when writing the test cases!) */
elem = xml_parse(&env, *bad_resp, strlen(*bad_resp));
TEST_NO_FAULT(&env);
xml_element_free(elem);
/* Now, make sure the higher-level routine barfs appropriately. */
xmlrpc_env_init(&env2);
v = xmlrpc_parse_response(&env2, *bad_resp, strlen(*bad_resp));
TEST(env2.fault_occurred);
TEST(env2.fault_code != 0); /* We use 0 as a code in our bad faults. */
TEST(v == NULL);
xmlrpc_env_clean(&env2);
}
xmlrpc_env_clean(&env);
}
static void test_parse_xml_call (void)
{
xmlrpc_env env, env2;
static void
test_parse_xml_call(void) {
xmlrpc_env env;
const char *method_name;
xmlrpc_value *params;
int i1, i2;
@@ -251,37 +515,33 @@ static void test_parse_xml_call (void)
xmlrpc_decompose_value(&env, params, "(ii)", &i1, &i2);
xmlrpc_DECREF(params);
TEST_NO_FAULT(&env);
TEST(strcmp(method_name, "gloom&doom") == 0);
TEST(streq(method_name, "gloom&doom"));
TEST(i1 == 10 && i2 == 20);
strfree(method_name);
/* Test some poorly-formed XML data. */
xmlrpc_env_init(&env2);
xmlrpc_parse_call(&env2, unparseable_value, strlen(unparseable_value),
xmlrpc_parse_call(&env, unparseable_value, strlen(unparseable_value),
&method_name, &params);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
TEST(method_name == NULL && params == NULL);
xmlrpc_env_clean(&env2);
/* Next, check for bogus values. These are all well-formed XML, but
** they aren't legal XML-RPC. */
for (bad_call = bad_calls; *bad_call != NULL; bad_call++) {
they aren't legal XML-RPC.
*/
for (bad_call = bad_calls; *bad_call != NULL; ++bad_call) {
/* First, check to make sure that our test case is well-formed XML.
** (It's easy to make mistakes when writing the test cases!) */
elem = xml_parse(&env, *bad_call, strlen(*bad_call));
xml_parse(&env, *bad_call, strlen(*bad_call), &elem);
TEST_NO_FAULT(&env);
xml_element_free(elem);
/* Now, make sure the higher-level routine barfs appropriately. */
xmlrpc_env_init(&env2);
xmlrpc_parse_call(&env2, *bad_call, strlen(*bad_call),
xmlrpc_parse_call(&env, *bad_call, strlen(*bad_call),
&method_name, &params);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
TEST_FAULT(&env, XMLRPC_PARSE_ERROR);
TEST(method_name == NULL && params == NULL);
xmlrpc_env_clean(&env2);
}
xmlrpc_env_clean(&env);
}
@@ -290,8 +550,14 @@ static void test_parse_xml_call (void)
void
test_parse_xml(void) {
printf("Running XML parsing tests.\n");
test_expat();
test_parse_xml_value();
test_parse_xml_response();
testParseNumberValue();
testParseMiscSimpleValue();
testParseGoodResponse();
testParseFaultResponse();
testParseBadResponse();
test_parse_xml_call();
printf("\n");
printf("XML parsing tests done.\n");
}
+142 -101
View File
@@ -8,8 +8,10 @@
#include "test.h"
#include "xml_data.h"
#include "serialize.h"
#include "girstring.h"
#include "serialize_value.h"
#include "serialize.h"
static void
@@ -59,109 +61,19 @@ test_serialize_basic(void) {
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
test_serialize_struct(void) {
/* Serialize a simple struct. */
char const serialized_struct[] =
"<value><struct>\r\n" \
"<member><name>&lt;&amp;&gt;</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_methodResponse(void) {
/* Serialize a methodResponse. */
char const serialized_response[] =
XML_PROLOGUE
"<methodResponse>\r\n"
"<params>\r\n"
"<param><value><i4>30</i4></value></param>\r\n"
"</params>\r\n"
"</methodResponse>\r\n";
xmlrpc_env env;
xmlrpc_value * v;
xmlrpc_mem_block *output;
@@ -258,17 +170,146 @@ test_serialize_fault(void) {
static void
test_serialize_apache_value(void) {
char const serializedData[] =
"<value><array><data>\r\n"
"<value><i4>7</i4></value>\r\n"
"<value><ex.i8>8</ex.i8></value>\r\n"
"<value><ex.nil/></value>\r\n"
"</data></array></value>";
xmlrpc_env env;
xmlrpc_value * valueP;
xmlrpc_mem_block * outputP;
size_t size;
xmlrpc_env_init(&env);
valueP = xmlrpc_build_value(&env, "(iIn)", 7, (xmlrpc_int64)8);
TEST_NO_FAULT(&env);
outputP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_value2(&env, outputP, valueP, xmlrpc_dialect_apache);
TEST_NO_FAULT(&env);
size = XMLRPC_MEMBLOCK_SIZE(char, outputP);
TEST(size == strlen(serializedData));
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, outputP), serializedData, size));
XMLRPC_MEMBLOCK_FREE(char, outputP);
xmlrpc_DECREF(valueP);
xmlrpc_env_clean(&env);
}
static void
test_serialize_apache_params(void) {
char const serializedData[] =
"<params>\r\n"
"<param><value><i4>7</i4></value></param>\r\n"
"<param><value><ex.i8>8</ex.i8></value></param>\r\n"
"</params>\r\n";
xmlrpc_env env;
xmlrpc_value * paramArrayP;
xmlrpc_mem_block * outputP;
size_t size;
xmlrpc_env_init(&env);
paramArrayP = xmlrpc_build_value(&env, "(iI)", 7, (xmlrpc_int64)8);
TEST_NO_FAULT(&env);
outputP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_params2(&env, outputP, paramArrayP,
xmlrpc_dialect_apache);
TEST_NO_FAULT(&env);
size = XMLRPC_MEMBLOCK_SIZE(char, outputP);
TEST(size == strlen(serializedData));
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, outputP), serializedData, size));
XMLRPC_MEMBLOCK_FREE(char, outputP);
xmlrpc_DECREF(paramArrayP);
xmlrpc_env_clean(&env);
}
static void
test_serialize_apache_response(void) {
char const serializedData[] =
XML_PROLOGUE
"<methodResponse>\r\n"
"<params>\r\n"
"<param><value><ex.i8>8</ex.i8></value></param>\r\n"
"</params>\r\n"
"</methodResponse>\r\n";
xmlrpc_env env;
xmlrpc_value * resultP;
xmlrpc_mem_block * outputP;
size_t size;
xmlrpc_env_init(&env);
resultP = xmlrpc_i8_new(&env, 8);
TEST_NO_FAULT(&env);
outputP = XMLRPC_MEMBLOCK_NEW(char, &env, 0);
TEST_NO_FAULT(&env);
xmlrpc_serialize_response2(&env, outputP, resultP,
xmlrpc_dialect_apache);
TEST_NO_FAULT(&env);
size = XMLRPC_MEMBLOCK_SIZE(char, outputP);
TEST(size == strlen(serializedData));
TEST(memeq(XMLRPC_MEMBLOCK_CONTENTS(char, outputP), serializedData, size));
XMLRPC_MEMBLOCK_FREE(char, outputP);
xmlrpc_DECREF(resultP);
xmlrpc_env_clean(&env);
}
static void
test_serialize_apache(void) {
/* Serialize various things using the Apache dialect of XML-RPC */
test_serialize_apache_value();
test_serialize_apache_params();
test_serialize_apache_response();
}
void
test_serialize(void) {
printf("Running serialize tests.");
test_serialize_basic();
test_serialize_double();
test_serialize_struct();
printf("\n");
test_serialize_value();
test_serialize_methodResponse();
test_serialize_methodCall();
test_serialize_fault();
test_serialize_apache();
printf("\n");
printf("Serialize tests done.\n");
+240
View File
@@ -0,0 +1,240 @@
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "xmlrpc_config.h"
#include "xmlrpc-c/base.h"
#include "test.h"
#include "girstring.h"
#include "serialize_value.h"
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&#x0d;bar</string></value>",
XMLRPC_MEMBLOCK_SIZE(char, xmlP)));
XMLRPC_MEMBLOCK_FREE(char, xmlP);
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_double(void) {
testOneDouble(0);
testOneDouble(1);
testOneDouble(0.3);
testOneDouble(4.9);
testOneDouble(-8);
testOneDouble(-.7);
testOneDouble(-2.5);
testOneDouble(3.14159);
testOneDouble(1.2E37);
testOneDouble(1.2E-37);
testOneDouble(-5E200);
}
static void
test_serialize_struct(void) {
/* Serialize a simple struct. */
char const serialized_struct[] =
"<value><struct>\r\n" \
"<member><name>&lt;&amp;&gt;</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);
}
void
test_serialize_value(void) {
printf(" Running serialize value tests.");
test_serialize_string();
test_serialize_double();
test_serialize_struct();
printf("\n");
printf(" Serialize value tests done.\n");
}
+7
View File
@@ -0,0 +1,7 @@
#ifndef SERIALIZE_VALUE_H_INCLUDED
#define SERIALIZE_VALUE_H_INCLUDED
void
test_serialize_value(void);
#endif
+118 -13
View File
@@ -1,3 +1,4 @@
#include "unistdx.h"
#include <stdio.h>
#include "xmlrpc_config.h"
@@ -12,33 +13,137 @@
#include "server_abyss.h"
void
test_server_abyss(void) {
static void
testSetHandlers(TServer * const abyssServerP) {
xmlrpc_env env;
xmlrpc_registry * registryP;
TServer abyssServer;
printf("Running Abyss server tests...\n");
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
TEST(registryP != NULL);
TEST_NO_FAULT(&env);
TEST(registryP != NULL);
xmlrpc_server_abyss_set_handler(&env, abyssServerP, "/RPC3", registryP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_set_handlers2(abyssServerP, "/RPC4", registryP);
xmlrpc_registry_free(registryP);
{
xmlrpc_registry * registryP;
registryP = xmlrpc_registry_new(&env);
xmlrpc_server_abyss_set_handlers(abyssServerP, registryP);
xmlrpc_registry_free(registryP);
}
xmlrpc_env_clean(&env);
}
static void
testServerParms(void) {
xmlrpc_server_abyss_parms parms;
parms.config_file_name = NULL;
parms.registryP = NULL;
parms.port_number = 1000;
parms.log_file_name = "/tmp/xmlrpc_logfile";
parms.keepalive_timeout = 5;
parms.keepalive_max_conn = 4;
parms.timeout = 50;
parms.dont_advertise = TRUE;
parms.uri_path = "/RPC9";
parms.chunk_response = TRUE;
};
static void
testObject(void) {
xmlrpc_env env;
xmlrpc_server_abyss_parms parms;
xmlrpc_server_abyss_t * serverP;
xmlrpc_registry * registryP;
xmlrpc_server_abyss_sig * oldHandlersP;
xmlrpc_env_init(&env);
registryP = xmlrpc_registry_new(&env);
TEST_NO_FAULT(&env);
parms.config_file_name = NULL;
parms.registryP = registryP;
serverP = NULL;
xmlrpc_server_abyss_create(&env, &parms, XMLRPC_APSIZE(registryP),
&serverP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); /* Global init not done */
xmlrpc_server_abyss_global_init(&env);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_create(&env, &parms, XMLRPC_APSIZE(registryP),
&serverP);
TEST_NO_FAULT(&env);
TEST(serverP != NULL);
xmlrpc_server_abyss_terminate(&env, serverP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_reset_terminate(&env, serverP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_use_sigchld(serverP);
xmlrpc_server_abyss_restore_sig(oldHandlersP);
TEST_NO_FAULT(&env);
xmlrpc_server_abyss_destroy(serverP);
xmlrpc_registry_free(registryP);
xmlrpc_server_abyss_global_term();
xmlrpc_server_abyss_setup_sig(&env, serverP, &oldHandlersP);
TEST_FAULT(&env, XMLRPC_INTERNAL_ERROR); /* Not globally initialized */
xmlrpc_env_clean(&env);
}
void
test_server_abyss(void) {
TServer abyssServer;
printf("Running Abyss XML-RPC server tests...\n");
ServerCreate(&abyssServer, "testserver", 8080, NULL, NULL);
xmlrpc_server_abyss_set_handlers(&abyssServer, registryP);
testSetHandlers(&abyssServer);
xmlrpc_server_abyss_set_handler(&env, &abyssServer, "/RPC3", registryP);
TEST_NO_FAULT(&env);
ServerSetKeepaliveTimeout(&abyssServer, 60);
ServerSetKeepaliveMaxConn(&abyssServer, 10);
ServerSetTimeout(&abyssServer, 0);
ServerSetAdvertise(&abyssServer, FALSE);
ServerFree(&abyssServer);
testServerParms();
testObject();
printf("\n");
printf("Abyss server tests done.\n");
printf("Abyss XML-RPC server tests done.\n");
}
+231 -384
View File
@@ -1,16 +1,24 @@
/* Copyright information is at the end of the file. */
#ifdef WIN32
#include <direct.h>
#else
#include <unistd.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <limits.h>
#include "casprintf.h"
#include "xmlrpc_config.h"
#include "xmlrpc-c/base.h"
#include "xmlrpc-c/server.h"
#include "bool.h"
#include "test.h"
#include "value.h"
#include "serialize.h"
@@ -18,7 +26,9 @@
#include "cgi.h"
#include "xml_data.h"
#include "client.h"
#include "abyss.h"
#include "server_abyss.h"
#include "method_registry.h"
/*=========================================================================
** Test Harness
@@ -40,6 +50,13 @@
int total_tests = 0;
int total_failures = 0;
bool const runningUnderWindows =
#ifdef WIN32
true;
#else
false;
#endif
/*=========================================================================
** Test Data
@@ -62,7 +79,6 @@ static int test_int_array_3[8] = {1, 2, 3, 4, 5, 6, 7, 8};
static void test_env(void)
{
xmlrpc_env env, env2;
char *s;
/* Test xmlrpc_env_init. */
xmlrpc_env_init(&env);
@@ -89,13 +105,6 @@ static void test_env(void)
TEST(env.fault_code == 3);
TEST(strcmp(env.fault_string, "abar9") == 0);
/* Set a fault with an oversized string. */
s = "12345678901234567890123456789012345678901234567890";
xmlrpc_env_set_fault_formatted(&env, 4, "%s%s%s%s%s%s", s, s, s, s, s, s);
TEST(env.fault_occurred);
TEST(env.fault_code == 4);
TEST(strlen(env.fault_string) == 255);
/* Test cleanup code (with help from memprof). */
xmlrpc_env_clean(&env);
@@ -195,15 +204,19 @@ static char *(base64_triplets[]) = {
"ZmdoaWprbG1ub3BxcnN0dXZ3eHl6QUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVo=\r\n",
NULL};
static void test_base64_conversion (void)
{
xmlrpc_env env, env2;
char **triplet, *bin_data, *nocrlf_ascii_data, *ascii_data;
xmlrpc_mem_block *output;
static void
test_base64_conversion(void) {
xmlrpc_env env;
char ** triplet;
xmlrpc_env_init(&env);
for (triplet = base64_triplets; *triplet != NULL; triplet += 3) {
char * bin_data;
char * nocrlf_ascii_data;
char * ascii_data;
xmlrpc_mem_block * output;
bin_data = *triplet;
nocrlf_ascii_data = *(triplet + 1);
ascii_data = *(triplet + 2);
@@ -242,19 +255,26 @@ static void test_base64_conversion (void)
}
/* Now for something broken... */
xmlrpc_env_init(&env2);
output = xmlrpc_base64_decode(&env2, "====", 4);
TEST(output == NULL);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env2);
{
xmlrpc_env env2;
xmlrpc_mem_block * output;
xmlrpc_env_init(&env2);
output = xmlrpc_base64_decode(&env2, "====", 4);
TEST(output == NULL);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env2);
}
/* Now for something broken in a really sneaky way... */
xmlrpc_env_init(&env2);
output = xmlrpc_base64_decode(&env2, "a==", 4);
TEST(output == NULL);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env2);
{
xmlrpc_env env2;
xmlrpc_mem_block * output;
xmlrpc_env_init(&env2);
output = xmlrpc_base64_decode(&env2, "a==", 4);
TEST(output == NULL);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
xmlrpc_env_clean(&env2);
}
xmlrpc_env_clean(&env);
}
@@ -290,249 +310,6 @@ static void test_bounds_checks (void)
/*=========================================================================
** test_method_registry
**=========================================================================
** We need to define some static callbacks to test this code.
*/
#define FOO_USER_DATA ((void*) 0xF00)
#define BAR_USER_DATA ((void*) 0xBAF)
static xmlrpc_value *test_foo (xmlrpc_env *env,
xmlrpc_value *param_array,
void *user_data)
{
xmlrpc_int32 x, y;
TEST_NO_FAULT(env);
TEST(param_array != NULL);
TEST(user_data == FOO_USER_DATA);
xmlrpc_decompose_value(env, param_array, "(ii)", &x, &y);
TEST_NO_FAULT(env);
TEST(x == 25);
TEST(y == 17);
return xmlrpc_build_value(env, "i", (xmlrpc_int32) x + y);
}
static xmlrpc_value *test_bar (xmlrpc_env *env,
xmlrpc_value *param_array,
void *user_data)
{
xmlrpc_int32 x, y;
TEST_NO_FAULT(env);
TEST(param_array != NULL);
TEST(user_data == BAR_USER_DATA);
xmlrpc_decompose_value(env, param_array, "(ii)", &x, &y);
TEST_NO_FAULT(env);
TEST(x == 25);
TEST(y == 17);
xmlrpc_env_set_fault(env, 123, "Test fault");
return NULL;
}
static xmlrpc_value *
test_default(xmlrpc_env * const env,
const char * const host ATTR_UNUSED,
const char * const method_name ATTR_UNUSED,
xmlrpc_value * const param_array,
void * const user_data) {
xmlrpc_int32 x, y;
TEST_NO_FAULT(env);
TEST(param_array != NULL);
TEST(user_data == FOO_USER_DATA);
xmlrpc_decompose_value(env, param_array, "(ii)", &x, &y);
TEST_NO_FAULT(env);
TEST(x == 25);
TEST(y == 17);
return xmlrpc_build_value(env, "i", 2 * (x + y));
}
static xmlrpc_value *
process_call_helper (xmlrpc_env *env,
xmlrpc_registry *registry,
const char *method_name,
xmlrpc_value *arg_array)
{
xmlrpc_mem_block *call, *response;
xmlrpc_value *value;
/* Build a call, and tell the registry to handle it. */
call = xmlrpc_mem_block_new(env, 0);
TEST_NO_FAULT(env);
xmlrpc_serialize_call(env, call, method_name, arg_array);
TEST_NO_FAULT(env);
response = xmlrpc_registry_process_call(env, registry, NULL,
xmlrpc_mem_block_contents(call),
xmlrpc_mem_block_size(call));
TEST_NO_FAULT(env);
TEST(response != NULL);
/* Parse the response. */
value = xmlrpc_parse_response(env, xmlrpc_mem_block_contents(response),
xmlrpc_mem_block_size(response));
xmlrpc_mem_block_free(call);
xmlrpc_mem_block_free(response);
return value;
}
static void
test_method_registry(void) {
xmlrpc_env env, env2;
xmlrpc_value *arg_array, *value;
xmlrpc_registry *registry;
xmlrpc_mem_block *response;
xmlrpc_int32 i;
xmlrpc_value *multi;
xmlrpc_int32 foo1_result, foo2_result;
xmlrpc_int32 bar_code, nosuch_code, multi_code, bogus1_code, bogus2_code;
char *bar_string, *nosuch_string, *multi_string;
char *bogus1_string, *bogus2_string;
xmlrpc_env_init(&env);
/* Create a new registry. */
registry = xmlrpc_registry_new(&env);
TEST(registry != NULL);
TEST_NO_FAULT(&env);
/* Add some test methods. */
xmlrpc_registry_add_method(&env, registry, NULL, "test.foo",
test_foo, FOO_USER_DATA);
TEST_NO_FAULT(&env);
xmlrpc_registry_add_method(&env, registry, NULL, "test.bar",
test_bar, BAR_USER_DATA);
TEST_NO_FAULT(&env);
/* Build an argument array for our calls. */
arg_array = xmlrpc_build_value(&env, "(ii)",
(xmlrpc_int32) 25, (xmlrpc_int32) 17);
TEST_NO_FAULT(&env);
/* Call test.foo and check the result. */
value = process_call_helper(&env, registry, "test.foo", arg_array);
TEST_NO_FAULT(&env);
TEST(value != NULL);
xmlrpc_decompose_value(&env, value, "i", &i);
xmlrpc_DECREF(value);
TEST_NO_FAULT(&env);
TEST(i == 42);
/* Call test.bar and check the result. */
xmlrpc_env_init(&env2);
value = process_call_helper(&env2, registry, "test.bar", arg_array);
TEST_FAULT(&env2, 123);
TEST(env2.fault_string && strcmp(env2.fault_string, "Test fault") == 0);
xmlrpc_env_clean(&env2);
/* Call a non-existant method and check the result. */
xmlrpc_env_init(&env2);
value = process_call_helper(&env2, registry, "test.nosuch", arg_array);
TEST(value == NULL);
TEST_FAULT(&env2, XMLRPC_NO_SUCH_METHOD_ERROR);
xmlrpc_env_clean(&env2);
/* Test system.multicall. */
multi = xmlrpc_build_value(&env,
"(({s:s,s:V}{s:s,s:V}{s:s,s:V}"
"{s:s,s:()}s{}{s:s,s:V}))",
"methodName", "test.foo",
"params", arg_array,
"methodName", "test.bar",
"params", arg_array,
"methodName", "test.nosuch",
"params", arg_array,
"methodName", "system.multicall",
"params",
"bogus_entry",
"methodName", "test.foo",
"params", arg_array);
TEST_NO_FAULT(&env);
value = process_call_helper(&env, registry, "system.multicall", multi);
TEST_NO_FAULT(&env);
xmlrpc_decompose_value(&env, value,
"((i){s:i,s:s,*}{s:i,s:s,*}"
"{s:i,s:s,*}{s:i,s:s,*}{s:i,s:s,*}(i))",
&foo1_result,
"faultCode", &bar_code,
"faultString", &bar_string,
"faultCode", &nosuch_code,
"faultString", &nosuch_string,
"faultCode", &multi_code,
"faultString", &multi_string,
"faultCode", &bogus1_code,
"faultString", &bogus1_string,
"faultCode", &bogus2_code,
"faultString", &bogus2_string,
&foo2_result);
xmlrpc_DECREF(value);
TEST_NO_FAULT(&env);
TEST(foo1_result == 42);
TEST(bar_code == 123);
TEST(strcmp(bar_string, "Test fault") == 0);
TEST(nosuch_code == XMLRPC_NO_SUCH_METHOD_ERROR);
TEST(multi_code == XMLRPC_REQUEST_REFUSED_ERROR);
TEST(foo2_result == 42);
xmlrpc_DECREF(multi);
free(bar_string);
free(nosuch_string);
free(multi_string);
free(bogus1_string);
free(bogus2_string);
/* PASS bogus XML data and make sure our parser pukes gracefully.
** (Because of the way the code is laid out, and the presence of other
** test suites, this lets us skip tests for invalid XML-RPC data.) */
xmlrpc_env_init(&env2);
response = xmlrpc_registry_process_call(&env, registry, NULL,
expat_error_data,
strlen(expat_error_data));
TEST_NO_FAULT(&env);
TEST(response != NULL);
value = xmlrpc_parse_response(&env2, xmlrpc_mem_block_contents(response),
xmlrpc_mem_block_size(response));
TEST(value == NULL);
TEST_FAULT(&env2, XMLRPC_PARSE_ERROR);
xmlrpc_mem_block_free(response);
xmlrpc_env_clean(&env2);
xmlrpc_registry_set_default_method(&env, registry, &test_default,
FOO_USER_DATA);
TEST_NO_FAULT(&env);
value = process_call_helper(&env, registry, "test.nosuch", arg_array);
TEST_NO_FAULT(&env);
TEST(value != NULL);
xmlrpc_decompose_value(&env, value, "i", &i);
xmlrpc_DECREF(value);
TEST_NO_FAULT(&env);
TEST(i == 84);
/* Change the default method. */
xmlrpc_registry_set_default_method(&env, registry, &test_default,
BAR_USER_DATA);
TEST_NO_FAULT(&env);
/* Test cleanup code (w/memprof). */
xmlrpc_registry_free(registry);
xmlrpc_DECREF(arg_array);
xmlrpc_env_clean(&env);
}
static void test_nesting_limit (void)
{
xmlrpc_env env;
@@ -540,16 +317,21 @@ static void test_nesting_limit (void)
xmlrpc_env_init(&env);
/* Test with an adequate limit for (...(...()...)...). */
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 2);
val = xmlrpc_parse_response(&env, correct_value, strlen(correct_value));
/* Test with an adequate limit for a result value which is an
array which contains an element which is a struct, whose values
are simple: 3.
*/
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 3);
val = xmlrpc_parse_response(&env,
good_response_xml, strlen(good_response_xml));
TEST_NO_FAULT(&env);
TEST(val != NULL);
xmlrpc_DECREF(val);
/* Test with an inadequate limit. */
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 1);
val = xmlrpc_parse_response(&env, correct_value, strlen(correct_value));
xmlrpc_limit_set(XMLRPC_NESTING_LIMIT_ID, 2);
val = xmlrpc_parse_response(&env,
good_response_xml, strlen(good_response_xml));
TEST_FAULT(&env, XMLRPC_PARSE_ERROR); /* BREAKME - Will change. */
TEST(val == NULL);
@@ -561,16 +343,19 @@ static void test_nesting_limit (void)
xmlrpc_env_clean(&env);
}
static void test_xml_size_limit (void)
{
xmlrpc_env env;
const char *method_name;
xmlrpc_value *params, *val;
static void
test_xml_size_limit(void) {
xmlrpc_env env;
const char * methodName;
xmlrpc_value * paramsP;
/* NOTE - This test suite only verifies the last-ditch size-checking
** code. There should also be matching code in all server (and
** preferably all client) modules as well. */
code. There should also be matching code in all server (and
preferably all client) modules as well.
*/
/* Set our XML size limit to something ridiculous. */
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, 6);
@@ -578,23 +363,29 @@ static void test_xml_size_limit (void)
/* Attempt to parse a call. */
xmlrpc_env_init(&env);
xmlrpc_parse_call(&env, serialized_call, strlen(serialized_call),
&method_name, &params);
&methodName, &paramsP);
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
TEST(method_name == NULL);
TEST(params == NULL);
xmlrpc_env_clean(&env);
/* Attempt to parse a response. */
xmlrpc_env_init(&env);
val = xmlrpc_parse_response(&env, correct_value, strlen(correct_value));
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
TEST(val == NULL);
xmlrpc_env_clean(&env);
{
xmlrpc_value * resultP;
int faultCode;
const char * faultString;
/* Attempt to parse a response. */
xmlrpc_env_init(&env);
xmlrpc_parse_response2(&env,
good_response_xml, strlen(good_response_xml),
&resultP, &faultCode, &faultString);
TEST_FAULT(&env, XMLRPC_LIMIT_EXCEEDED_ERROR);
xmlrpc_env_clean(&env);
}
/* Reset the default limit. */
xmlrpc_limit_set(XMLRPC_XML_SIZE_LIMIT_ID, XMLRPC_XML_SIZE_LIMIT_DEFAULT);
}
/*=========================================================================
** test_sample_files
**=========================================================================
@@ -602,67 +393,105 @@ static void test_xml_size_limit (void)
** results.
**
** We use these files to test strange-but-legal encodings, illegal-but-
** supported encodings, etc.
** allowed-by-Xmlrpc-c encodings, etc.
*/
#ifdef WIN32
/* usually compiled in 'Windows' folder */
#define TESTDATA_DIR ".." DIRECTORY_SEPARATOR "bin" DIRECTORY_SEPARATOR "data"
#else
#define TESTDATA_DIR "data"
#endif
static char *good_requests[] = {
"req_out_of_order.xml",
"req_no_params.xml",
"req_value_name.xml",
static const char * goodRequests[] = {
TESTDATA_DIR DIRECTORY_SEPARATOR "req_out_of_order.xml",
TESTDATA_DIR DIRECTORY_SEPARATOR "req_no_params.xml",
TESTDATA_DIR DIRECTORY_SEPARATOR "req_value_name.xml",
NULL
};
#define MAX_SAMPLE_FILE_LEN (16 * 1024)
static char file_buff [MAX_SAMPLE_FILE_LEN];
static void
read_file (char *path, char **out_data, size_t *out_size)
{
FILE *f;
size_t bytes_read;
reportFileOpenError(const char * const path,
int const openErrno) {
/* Open the file. */
f = fopen(path, "r");
if (f == NULL) {
if (runningUnderWindows) {
char cwdname[1024];
char * succeeded;
succeeded = getcwd(cwdname, sizeof(cwdname));
if (succeeded)
fprintf(stderr, "Running in current work directory '%s'\n",
cwdname);
}
fprintf(stderr, "Could not open file '%s'. errno=%d (%s)\n",
path, openErrno, strerror(openErrno));
}
static void
readFile(const char * const path,
const char ** const outDataP,
size_t * const outSizeP) {
static char fileBuff[MAX_SAMPLE_FILE_LEN];
FILE * fileP;
size_t bytesRead;
fileP = fopen(path, "r");
if (fileP == NULL) {
/* Since this error is fairly likely to happen, give an
** informative error message... */
fflush(stdout);
fprintf(stderr, "Could not open file '%s'. errno=%d (%s)\n",
path, errno, strerror(errno));
abort();
informative error message...
*/
reportFileOpenError(path, errno);
exit(1);
}
/* Read in one buffer full of data, and make sure that everything
** fit. (We perform a lazy error/no-eof/zero-length-file test using
** bytes_read.) */
bytes_read = fread(file_buff, sizeof(char), MAX_SAMPLE_FILE_LEN, f);
TEST(0 < bytes_read && bytes_read < MAX_SAMPLE_FILE_LEN);
fit. (We perform a lazy error/no-eof/zero-length-file test using
'bytesRead'.)
*/
bytesRead = fread(fileBuff, sizeof(char), MAX_SAMPLE_FILE_LEN, fileP);
TEST(0 < bytesRead && bytesRead < MAX_SAMPLE_FILE_LEN);
fclose(fileP);
/* Close the file and return our data. */
fclose(f);
*out_data = file_buff;
*out_size = bytes_read;
*outDataP = fileBuff;
*outSizeP = bytesRead;
}
static void test_sample_files (void)
{
static void
testSampleFiles(void) {
xmlrpc_env env;
char **paths, *path;
char *data;
size_t data_len;
const char *method_name;
xmlrpc_value *params;
const char ** pathP;
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, &params);
for (pathP = goodRequests; *pathP != NULL; ++pathP) {
const char * const path = *pathP;
const char * data;
size_t dataLen;
const char * methodName;
xmlrpc_value * params;
readFile(path, &data, &dataLen);
xmlrpc_parse_call(&env, data, dataLen, &methodName, &params);
TEST_NO_FAULT(&env);
strfree(method_name);
strfree(methodName);
xmlrpc_DECREF(params);
}
@@ -679,7 +508,7 @@ static void test_sample_files (void)
** http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
*/
#ifdef HAVE_UNICODE_WCHAR
#if HAVE_UNICODE_WCHAR
typedef struct {
char *utf8;
@@ -760,6 +589,7 @@ static char *(bad_utf8[]) = {
NULL
};
#endif /* HAVE_UNICODE_WCHAR */
/* This routine is missing on certain platforms. This implementation
** *appears* to be correct. */
@@ -782,8 +612,10 @@ int wcsncmp(wchar_t *wcs1, wchar_t* wcs2, size_t len)
#endif /* HAVE_WCSNCMP */
#endif
static void test_utf8_coding (void)
{
static void
test_utf8_coding(void) {
#if HAVE_UNICODE_WCHAR
xmlrpc_env env, env2;
utf8_and_wcs *good_data;
char **bad_data;
@@ -841,72 +673,87 @@ static void test_utf8_coding (void)
TEST(output == NULL);
xmlrpc_env_clean(&env2);
}
xmlrpc_env_clean(&env);
#endif /* HAVE_UNICODE_WCHAR */
}
#endif /* HAVE_UNICODE_WCHAR */
/*=========================================================================
** Test Driver
**=========================================================================
*/
static void
test_server_cgi_maybe(void) {
#ifndef WIN32
test_server_cgi();
#endif
}
static void
test_client_maybe(void) {
#ifndef WIN32 /* Must get Windows Curl transport working for this to work */
test_client();
#endif
}
int
main(int argc,
char ** argv ATTR_UNUSED) {
int retval;
if (argc-1 > 0) {
fprintf(stderr, "There are no arguments.");
exit(1);
fprintf(stderr, "There are no arguments.\n");
retval = 1;
} else {
test_env();
test_mem_block();
test_base64_conversion();
printf("\n");
test_value();
test_bounds_checks();
printf("\n");
test_serialize();
test_parse_xml();
test_method_registry();
test_nesting_limit();
test_xml_size_limit();
testSampleFiles();
printf("\n");
test_server_cgi_maybe();
test_abyss();
test_server_abyss();
test_utf8_coding();
printf("\n");
test_client_maybe();
printf("\n");
/* Summarize our test run. */
printf("Ran %d tests, %d failed, %.1f%% passed\n",
total_tests, total_failures,
100.0 - (100.0 * total_failures) / total_tests);
/* Print the final result. */
if (total_failures == 0) {
printf("OK\n");
retval = 0;
} else {
retval = 1;
printf("FAILED\n");
}
}
/* Add your test suites here. */
test_env();
test_mem_block();
test_base64_conversion();
printf("\n");
test_value();
test_bounds_checks();
printf("\n");
test_serialize();
test_parse_xml();
test_method_registry();
test_nesting_limit();
test_xml_size_limit();
test_sample_files();
printf("\n");
#ifndef WIN32 /* CGI unsupported in Windows */
test_server_cgi();
#endif
test_server_abyss();
#ifdef HAVE_UNICODE_WCHAR
test_utf8_coding();
#endif /* HAVE_UNICODE_WCHAR */
printf("\n");
#ifndef WIN32 /* TODO: Client test uses curl... */
test_client();
#endif
/* Summarize our test run. */
printf("\nRan %d tests, %d failed, %.1f%% passed\n",
total_tests, total_failures,
100.0 - (100.0 * total_failures) / total_tests);
/* Print the final result. */
if (total_failures == 0) {
printf("OK\n");
return 0;
}
printf("FAILED\n");
return 1;
return retval;
}
+60 -18
View File
@@ -1,19 +1,17 @@
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "xmlrpc_config.h"
#include "xmlrpc-c/util.h"
#include "xmlrpc-c/util_int.h"
extern int total_tests;
extern int total_failures;
static __inline void
strfree(const char * const string) {
free((char*)string);
}
/* This is a good place to set a breakpoint. */
static __inline void
static __inline__ void
test_failure(const char * const file,
unsigned int const line,
const char * const label,
@@ -47,21 +45,65 @@ do { \
} \
} while (0)
#define TEST_FAULT(env, code) \
do { \
++total_tests; \
if ((env)->fault_occurred && (env)->fault_code == (code)) { \
printf("."); \
} else { \
test_failure(__FILE__, __LINE__, "wrong/no fault occurred", \
(env)->fault_string); \
} \
} while (0)
#define TEST_EPSILON 1E-5
#define FORCENONZERO(x) (MAX(fabs(x), TEST_EPSILON))
#define FLOATEQUAL(comparand, comparator) \
((fabs((comparand)-(comparator)))/FORCENONZERO(comparand) < TEST_EPSILON)
#define TESTFLOATEQUAL(comparand, comparator) \
TEST(FLOATEQUAL(comparand, comparator))
static __inline__ void
test_fault(xmlrpc_env * const envP,
int const expectedCode,
const char * const fileName,
unsigned int const lineNumber) {
++total_tests;
if (!envP->fault_occurred)
test_failure(fileName, lineNumber, "no fault occurred", "");
else if (envP->fault_code != expectedCode)
test_failure(fileName, lineNumber, "wrong fault occurred",
envP->fault_string);
else
printf(".");
xmlrpc_env_clean(envP);
xmlrpc_env_init(envP);
}
#define TEST_FAULT(envP, code) \
do { test_fault(envP, code, __FILE__, __LINE__); } while(0)
;
static __inline__ void
test_null_string(const char * const string,
const char * const fileName,
unsigned int const lineNumber) {
++total_tests;
if (string != NULL)
test_failure(fileName, lineNumber, "string not null", string);
else
printf(".");
}
#define TEST_NULL_STRING(string) \
do { test_null_string(string, __FILE__, __LINE__); } while(0)
;
#define TEST_ERROR(reason) \
do { \
printf("Unable to test at %s/%u. %s", __FILE__, __LINE__, reason); \
abort(); \
} while (0)
;
File diff suppressed because it is too large. Load diff
+9 -11
View File
@@ -1,6 +1,6 @@
#include <stddef.h>
#define XML_PROLOGUE "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
#include "xml_data.h"
#define RAW_STRING_DATA \
"<value><array><data>\r\n" \
@@ -31,14 +31,6 @@ char const serialized_call[] =
"</params>\r\n"
"</methodCall>\r\n";
char const serialized_response[] =
XML_PROLOGUE
"<methodResponse>\r\n"
"<params>\r\n"
"<param><value><i4>30</i4></value></param>\r\n"
"</params>\r\n"
"</methodResponse>\r\n";
char const serialized_fault[] =
XML_PROLOGUE
"<methodResponse>\r\n"
@@ -56,8 +48,10 @@ char const expat_data[] = XML_PROLOGUE RAW_STRING_DATA "\r\n";
char const expat_error_data[] =
XML_PROLOGUE \
"<foo><bar>abc</bar><baz></baz>\r\n";
/* Invalid because there's no closing </foo> */
char const correct_value[] =
char const good_response_xml[] =
XML_PROLOGUE
"<methodResponse><params><param>\r\n"
"<value><array><data>\r\n"
@@ -100,8 +94,12 @@ const char * bad_values[] = {
VALUE_HEADER"<i4>0 </i4>"VALUE_FOOTER,
VALUE_HEADER"<boolean>2</boolean>"VALUE_FOOTER,
VALUE_HEADER"<boolean>-1</boolean>"VALUE_FOOTER,
VALUE_HEADER"<double> 0.0</double>"VALUE_FOOTER,
VALUE_HEADER"<double></double>"VALUE_FOOTER,
VALUE_HEADER"<double>0.0 </double>"VALUE_FOOTER,
VALUE_HEADER"<double>a</double>"VALUE_FOOTER,
VALUE_HEADER"<double>1.1.1</double>"VALUE_FOOTER,
VALUE_HEADER"<double>1a</double>"VALUE_FOOTER,
VALUE_HEADER"<double>1.1a</double>"VALUE_FOOTER,
VALUE_HEADER"<array></array>"VALUE_FOOTER,
VALUE_HEADER"<array><data></data><data></data></array>"VALUE_FOOTER,
VALUE_HEADER"<array><data></data><data></data></array>"VALUE_FOOTER,
+8 -3
View File
@@ -1,15 +1,18 @@
#ifndef XML_DATA_H_INCLUDED
#define XML_DATA_H_INCLUDED
#define XML_PROLOGUE "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"
extern char const serialized_data[];
extern char const serialized_call[];
extern char const serialized_response[];
extern char const serialized_fault[];
extern char const expat_data[];
extern char const expat_error_data[];
extern char const correct_value[];
extern char const good_response_xml[];
extern char const unparseable_value[];
@@ -18,3 +21,5 @@ extern const char *(bad_values[]);
extern const char *(bad_responses[]);
extern const char *(bad_calls[]);
#endif