mirror of
https://github.com/signalwire/freeswitch.git
synced 2026-11-17 06:48:33 +00:00
merged new xmlrpc-c revision 1472 from https://xmlrpc-c.svn.sourceforge.net/svnroot/xmlrpc-c/trunk
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@8545 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
1 parent
d2290cfa3a
commit
00654d880e
338 files changed
+55722
-19397
No files matched your search
@@ -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
|
||||
@@ -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");
|
||||
}
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
void
|
||||
test_abyss(void);
|
||||
@@ -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
@@ -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");
|
||||
|
||||
@@ -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>
|
||||
@@ -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);
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
#ifndef TEST_METHOD_REGISTRY_H_INCLUDED
|
||||
#define TEST_METHOD_REGISTRY_H_INCLUDED
|
||||
|
||||
void
|
||||
test_method_registry(void);
|
||||
|
||||
#endif
|
||||
+410
-144
@@ -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, ¶mArrayP);
|
||||
TEST_NO_FAULT(&env);
|
||||
|
||||
arraySize = xmlrpc_array_size(&env, paramArrayP);
|
||||
TEST_NO_FAULT(&env);
|
||||
|
||||
TEST(arraySize == 16);
|
||||
|
||||
xmlrpc_decompose_value(
|
||||
&env, paramArrayP, "(iiiiiIIddddddddd)",
|
||||
&int_max, &int_min, &i_i1, &i_i2, &i_i4, &i_i8, &i_ex_i8,
|
||||
&d1, &d2, &d3, &d4, &d5, &d6, &d7, &d8, &d9);
|
||||
|
||||
TEST_NO_FAULT(&env);
|
||||
|
||||
TEST(int_max == INT_MAX);
|
||||
TEST(int_min == INT_MIN);
|
||||
TEST(i_i1 == 10);
|
||||
TEST(i_i2 == 10);
|
||||
TEST(i_i4 == 10);
|
||||
TEST(i_i8 == 10);
|
||||
TEST(i_ex_i8 == 10);
|
||||
TESTFLOATEQUAL(d1, 10.0);
|
||||
TESTFLOATEQUAL(d2, 10.1);
|
||||
TESTFLOATEQUAL(d3, -10.1);
|
||||
TESTFLOATEQUAL(d4, +10.1);
|
||||
TESTFLOATEQUAL(d5, 0.0);
|
||||
TESTFLOATEQUAL(d6, 0.01);
|
||||
TESTFLOATEQUAL(d7, 5.0);
|
||||
TESTFLOATEQUAL(d8, 5.3E6);
|
||||
TESTFLOATEQUAL(d9, 1.0);
|
||||
|
||||
xmlrpc_DECREF(paramArrayP);
|
||||
strfree(methodName);
|
||||
|
||||
xmlrpc_env_clean(&env);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void
|
||||
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, ¶mArrayP);
|
||||
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, ¶ms);
|
||||
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, ¶ms);
|
||||
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
@@ -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><&></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");
|
||||
|
||||
@@ -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
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><&></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");
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
#ifndef SERIALIZE_VALUE_H_INCLUDED
|
||||
#define SERIALIZE_VALUE_H_INCLUDED
|
||||
|
||||
void
|
||||
test_serialize_value(void);
|
||||
|
||||
#endif
|
||||
@@ -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
@@ -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, ¶ms);
|
||||
&methodName, ¶msP);
|
||||
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, ¶ms);
|
||||
|
||||
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, ¶ms);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
;
|
||||
+863
-218
File diff suppressed because it is too large.
Load diff
@@ -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,
|
||||
|
||||
@@ -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
|
||||
Reference in new issue
Block a user