ossp-pkg/xds/xds_test_xdr.c
/*
** OSSP xds - Extensible Data Serialization
** Copyright (c) 2001-2005 Ralf S. Engelschall <rse@engelschall.com>
** Copyright (c) 2001-2005 The OSSP Project <http://www.ossp.org/>
** Copyright (c) 2001-2005 Cable & Wireless <http://www.cw.com/>
**
** This file is part of OSSP xds, an extensible data serialization
** library which can be found at http://www.ossp.org/pkg/lib/xds/.
**
** Permission to use, copy, modify, and distribute this software for
** any purpose with or without fee is hereby granted, provided that
** the above copyright notice and this permission notice appear in all
** copies.
**
** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
** WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
** MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
** CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
** USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
** OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
** OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
** SUCH DAMAGE.
**
** xds_test_xdr.c: test suite for XDR encodig/decoding engine
*/
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <rpc/types.h>
#include <rpc/xdr.h>
#include "xds.h"
#ifdef XDS_TEST_XDR_INT32
int main(int argc, char *argv[])
{
XDR xdrs;
char xdr_buf[1024];
size_t xdr_buf_size;
xds_t *xds;
char *xds_buf;
size_t xds_buf_size;
xds_int32_t values[] = {
0x00000000,
0x12345678,
-0x12345678,
0x7bcdef01,
-0x7bcdef01,
0x7fffffff
};
size_t i;
/* Encode the values array using the RPC-XDR implementation. */
xdrmem_create(&xdrs, xdr_buf, sizeof (xdr_buf), XDR_ENCODE);
for (i = 0; i < sizeof (values) / sizeof (xds_int32_t); ++i)
xdr_int32_t(&xdrs, &values[i]);
xdr_buf_size = xdr_getpos(&xdrs);
xdr_destroy(&xdrs);
/* Encode the values array using the XDS implementation. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "int", &xdr_encode_int32, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (xds_int32_t); ++i) {
if (xds_encode(xds, "int", values[i]) != XDS_OK) {
printf("xds_encode(values[%d]) failed!\n", i);
return 1;
}
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&xds_buf, &xds_buf_size) !=
XDS_OK) {
printf("getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
/* Both buffers must be equal now. */
if (xdr_buf_size != xds_buf_size) {
printf("The buffer sizes don't match: %d != %d.\n", xdr_buf_size,
xds_buf_size);
return 1;
}
if (memcmp(xds_buf, xdr_buf, xds_buf_size) != 0) {
printf("The buffers' contents is not identical!\n");
return 1;
}
/* Now we decode the values again using the XDS implementation and
compare them to our original values. Obviously, they should not
differ. */
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "int", &xdr_decode_int32, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, xds_buf, xds_buf_size) != XDS_OK) {
printf("setbuffer() failed.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (xds_int32_t); ++i) {
xds_int32_t tmp;
if (xds_decode(xds, "int", &tmp) != XDS_OK) {
printf("xds_encode() failed for the %d value!\n", i);
return 1;
}
if (values[i] != tmp) {
printf("The %dth value has not been decoded correctly!\n", i);
return 1;
}
}
xds_destroy(xds);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_INT32 */
#ifdef XDS_TEST_XDR_UINT32
#ifdef __FreeBSD__
static int xdr_uint32_t(XDR *xdrs, uint32_t *val)
{
return xdr_u_int32_t(xdrs, val);
}
#endif
int main(int argc, char *argv[])
{
XDR xdrs;
char xdr_buf[1024];
size_t xdr_buf_size;
xds_t *xds;
char *xds_buf;
size_t xds_buf_size;
xds_uint32_t values[] = {
0x00000000,
0x12345678,
0xabcdef01,
0xc500b3ef,
0xffffffff
};
size_t i;
/* Encode the values array using the RPC-XDR implementation. */
xdrmem_create(&xdrs, xdr_buf, sizeof (xdr_buf), XDR_ENCODE);
for (i = 0; i < sizeof (values) / sizeof (xds_uint32_t); ++i)
xdr_uint32_t(&xdrs, &values[i]);
xdr_buf_size = xdr_getpos(&xdrs);
xdr_destroy(&xdrs);
/* Encode the values array using the XDS implementation. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "uint", &xdr_encode_uint32, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (uint32_t); ++i) {
if (xds_encode(xds, "uint", values[i]) != XDS_OK) {
printf("xds_encode(values[%d]) failed!\n", i);
return 1;
}
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&xds_buf, &xds_buf_size) !=
XDS_OK) {
printf("getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
/* Both buffers must be equal now. */
if (xdr_buf_size != xds_buf_size) {
printf("The buffer sizes don't match: %d != %d.\n", xdr_buf_size,
xds_buf_size);
return 1;
}
if (memcmp(xds_buf, xdr_buf, xds_buf_size) != 0) {
printf("The buffers' contents is not identical!\n");
return 1;
}
/* Now we decode the values again using the XDS implementation and
compare them to our original values. Obviously, they should not
differ. */
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "uint", &xdr_decode_uint32, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, xds_buf, xds_buf_size) != XDS_OK) {
printf("setbuffer() failed.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (xds_uint32_t); ++i) {
xds_uint32_t tmp;
if (xds_decode(xds, "uint", &tmp) != XDS_OK) {
printf("xds_encode() failed for the %d value!\n", i);
return 1;
}
if (values[i] != tmp) {
printf("The %dth value has not been decoded correctly!\n", i);
return 1;
}
}
xds_destroy(xds);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_UINT32 */
#ifdef XDS_TEST_XDR_INT64
#ifdef XDS_HAVE_64_BIT_SUPPORT
int main(int argc, char *argv[])
{
XDR xdrs;
char xdr_buf[1024];
size_t xdr_buf_size;
xds_t *xds;
char *xds_buf;
size_t xds_buf_size;
xds_int64_t values[] = {
0x0000000000000000LL,
0x123456789abcdef0LL,
-0x123456789abcdef0LL,
0x7bcdef01cc45bb9aLL,
-0x7bcdef01cc45bb9aLL,
0x7fffffffffffffffLL
};
size_t i;
/* Encode the values array using the RPC-XDR implementation. */
xdrmem_create(&xdrs, xdr_buf, sizeof (xdr_buf), XDR_ENCODE);
for (i = 0; i < sizeof (values) / sizeof (xds_int64_t); ++i)
xdr_int64_t(&xdrs, &values[i]);
xdr_buf_size = xdr_getpos(&xdrs);
xdr_destroy(&xdrs);
/* Encode the values array using the XDS implementation. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "int", &xdr_encode_int64, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (xds_int64_t); ++i) {
if (xds_encode(xds, "int", values[i]) != XDS_OK) {
printf("xds_encode(values[%d]) failed!\n", i);
return 1;
}
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&xds_buf, &xds_buf_size) !=
XDS_OK) {
printf("getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
/* Both buffers must be equal now. */
if (xdr_buf_size != xds_buf_size) {
printf("The buffer sizes don't match: %d != %d.\n", xdr_buf_size,
xds_buf_size);
return 1;
}
if (memcmp(xds_buf, xdr_buf, xds_buf_size) != 0) {
printf("The buffers' contents is not identical!\n");
return 1;
}
/* Now we decode the values again using the XDS implementation and
compare them to our original values. Obviously, they should not
differ. */
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "int", &xdr_decode_int64, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, xds_buf, xds_buf_size) != XDS_OK) {
printf("setbuffer() failed.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (xds_int64_t); ++i) {
xds_int64_t tmp;
if (xds_decode(xds, "int", &tmp) != XDS_OK) {
printf("xds_encode() failed for the %d value!\n", i);
return 1;
}
if (values[i] != tmp) {
printf("The %dth value has not been decoded correctly!\n", i);
return 1;
}
}
xds_destroy(xds);
/* Everything went fine. */
return 0;
}
#endif /* XDS_HAVE_64_BIT_SUPPORT */
#endif /* XDS_TEST_XDR_INT64 */
#ifdef XDS_TEST_XDR_UINT64
#ifdef XDS_HAVE_64_BIT_SUPPORT
#ifdef __FreeBSD__
static int xdr_uint64_t(XDR *xdrs, uint64_t *val)
{
return xdr_u_int64_t(xdrs, val);
}
#endif
int main(int argc, char *argv[])
{
XDR xdrs;
char xdr_buf[1024];
size_t xdr_buf_size;
xds_t *xds;
char *xds_buf;
size_t xds_buf_size;
xds_uint64_t values[] = {
0x0000000000000000ULL,
0x123456789abcdef0ULL,
0xabcdef01cc45bb9aULL,
0xc500b3efdd34ca9eULL,
0xffffffffffffffffULL
};
size_t i;
/* Encode the values array using the RPC-XDR implementation. */
xdrmem_create(&xdrs, xdr_buf, sizeof (xdr_buf), XDR_ENCODE);
for (i = 0; i < sizeof (values) / sizeof (xds_uint64_t); ++i)
xdr_uint64_t(&xdrs, &values[i]);
xdr_buf_size = xdr_getpos(&xdrs);
xdr_destroy(&xdrs);
/* Encode the values array using the XDS implementation. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "uint", &xdr_encode_uint64, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (uint64_t); ++i) {
if (xds_encode(xds, "uint", values[i]) != XDS_OK) {
printf("xds_encode(values[%d]) failed!\n", i);
return 1;
}
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&xds_buf, &xds_buf_size) !=
XDS_OK) {
printf("getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
/* Both buffers must be equal now. */
if (xdr_buf_size != xds_buf_size) {
printf("The buffer sizes don't match: %d != %d.\n", xdr_buf_size,
xds_buf_size);
return 1;
}
if (memcmp(xds_buf, xdr_buf, xds_buf_size) != 0) {
printf("The buffers' contents is not identical!\n");
return 1;
}
/* Now we decode the values again using the XDS implementation and
compare them to our original values. Obviously, they should not
differ. */
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "uint", &xdr_decode_uint64, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, xds_buf, xds_buf_size) != XDS_OK) {
printf("setbuffer() failed.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (xds_uint64_t); ++i) {
xds_uint64_t tmp;
if (xds_decode(xds, "uint", &tmp) != XDS_OK) {
printf("xds_encode() failed for the %d value!\n", i);
return 1;
}
if (values[i] != tmp) {
printf("The %dth value has not been decoded correctly!\n", i);
return 1;
}
}
xds_destroy(xds);
/* Everything went fine. */
return 0;
}
#endif /* XDS_HAVE_64_BIT_SUPPORT */
#endif /* XDS_TEST_XDR_UINT64 */
#ifdef XDS_TEST_XDR_STRING
int main(int argc, char *argv[])
{
xds_t *xds;
char *buffer;
size_t buffer_size;
char msg[] = "Hello World";
char *new_msg;
/* Encode the string as octet stream. Then erase the buffer and decode
the string back, verifying that it hasn't changed. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "string", &xdr_encode_string, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
if (xds_encode(xds, "string", msg) != XDS_OK) {
printf("xds_encode() failed.\n");
return 1;
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) !=
XDS_OK) {
printf("xds_getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
if (buffer_size % 4 != 0) {
printf("The encoded strings' buffer size is not a multiple of 4.\n");
return 1;
}
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "string", &xdr_decode_string, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, buffer, buffer_size) != XDS_OK) {
printf("xds_setbuffer() failed.\n");
return 1;
}
if (xds_decode(xds, "string", &new_msg) != XDS_OK) {
printf("xds_decode() failed.\n");
return 1;
}
if (strlen(new_msg) != sizeof (msg) - 1) {
printf("The size of the decoded message is wrong.\n");
return 1;
}
if (memcmp(msg, new_msg, sizeof (msg) - 1) != 0) {
printf("The decoded string is not correct.\n");
return 1;
}
xds_destroy(xds);
free(new_msg);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_STRING */
#ifdef XDS_TEST_XDR_STRING_EMPTY
int main(int argc, char *argv[])
{
xds_t *xds;
char *buffer;
size_t buffer_size;
char msg[] = "";
char *new_msg;
/* Encode the string as octet stream. Then erase the buffer and decode
the string back, verifying that it hasn't changed. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "string", &xdr_encode_string, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
if (xds_encode(xds, "string", msg, 0) != XDS_OK) {
printf("xds_encode() failed.\n");
return 1;
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) !=
XDS_OK) {
printf("xds_getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
if (buffer_size % 4 != 0) {
printf("The encoded strings' buffer size is not a multiple of 4.\n");
return 1;
}
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "string", &xdr_decode_string, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, buffer, buffer_size) != XDS_OK) {
printf("xds_setbuffer() failed.\n");
return 1;
}
if (xds_decode(xds, "string", &new_msg) != XDS_OK) {
printf("xds_decode() failed.\n");
return 1;
}
if (strlen(new_msg) != 0) {
printf("The size of the decoded message is wrong.\n");
return 1;
}
xds_destroy(xds);
free(new_msg);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_STRING_EMPTY */
#ifdef XDS_TEST_XDR_OCTETSTREAM
int main(int argc, char *argv[])
{
xds_t *xds;
char *buffer;
size_t buffer_size;
char msg[] = "Hello\000World";
char *new_msg;
size_t new_msg_size;
/* Encode the string as octet stream. Then erase the buffer and decode
the string back, verifying that it hasn't changed. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "os", &xdr_encode_octetstream, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
if (xds_encode(xds, "os", msg, sizeof (msg) - 1) != XDS_OK) {
printf("xds_encode() failed.\n");
return 1;
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) !=
XDS_OK) {
printf("xds_getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
if (buffer_size % 4 != 0) {
printf
("The encoded octet stream's buffer size is not a multiple of 4.\n");
return 1;
}
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "os", &xdr_decode_octetstream, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, buffer, buffer_size) != XDS_OK) {
printf("xds_setbuffer() failed.\n");
return 1;
}
if (xds_decode(xds, "os", &new_msg, &new_msg_size) != XDS_OK) {
printf("xds_decode() failed.\n");
return 1;
}
if (new_msg_size != sizeof (msg) - 1) {
printf("The size of the decoded message is wrong.\n");
return 1;
}
if (memcmp(msg, new_msg, new_msg_size) != 0) {
printf("The decoded octet stream is not correct.\n");
return 1;
}
xds_destroy(xds);
free(new_msg);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_OCTETSTREAM */
#ifdef XDS_TEST_XDR_OCTETSTREAM_EMPTY
int main(int argc, char *argv[])
{
xds_t *xds;
char *buffer;
size_t buffer_size;
char msg[] = "";
char *new_msg;
size_t new_msg_size;
/* Encode the string as octet stream. Then erase the buffer and decode
the string back, verifying that it hasn't changed. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "os", &xdr_encode_octetstream, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
if (xds_encode(xds, "os", msg, 0) != XDS_OK) {
printf("xds_encode() failed.\n");
return 1;
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) !=
XDS_OK) {
printf("xds_getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
if (buffer_size % 4 != 0) {
printf("The encoded octet stream's buffer size is not a multiple of 4.\n");
return 1;
}
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "os", &xdr_decode_octetstream, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, buffer, buffer_size) != XDS_OK) {
printf("xds_setbuffer() failed.\n");
return 1;
}
if (xds_decode(xds, "os", &new_msg, &new_msg_size) != XDS_OK) {
printf("xds_decode() failed.\n");
return 1;
}
if (new_msg_size != 0) {
printf("The size of the decoded message is wrong.\n");
return 1;
}
if (memcmp(msg, new_msg, new_msg_size) != 0) {
printf("The decoded octet stream is not correct.\n");
return 1;
}
xds_destroy(xds);
free(new_msg);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_OCTETSTREAM_EMPTY */
#ifdef XDS_TEST_XDR_FLOAT
int main(int argc, char *argv[])
{
XDR xdrs;
char xdr_buf[1024];
size_t xdr_buf_size;
xds_t *xds;
char *xds_buf;
size_t xds_buf_size;
float values[] =
{
0,
3.14,
-3.14,
0.14,
-0.14,
123456.789,
-123456.789
};
size_t i;
/* Encode the values array using the RPC-XDR implementation. */
xdrmem_create(&xdrs, xdr_buf, sizeof (xdr_buf), XDR_ENCODE);
for (i = 0; i < sizeof (values) / sizeof (float); ++i)
xdr_float(&xdrs, &values[i]);
xdr_buf_size = xdr_getpos(&xdrs);
xdr_destroy(&xdrs);
/* Encode the values array using the XDS implementation. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "float", &xdr_encode_float, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (float); ++i) {
if (xds_encode(xds, "float", values[i]) != XDS_OK) {
printf("xds_encode(values[%d]) failed!\n", i);
return 1;
}
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&xds_buf, &xds_buf_size) !=
XDS_OK) {
printf("getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
/* Both buffers must be equal now. */
if (xdr_buf_size != xds_buf_size) {
printf("The buffer sizes don't match: %d != %d.\n", xdr_buf_size,
xds_buf_size);
return 1;
}
if (memcmp(xds_buf, xdr_buf, xds_buf_size) != 0) {
printf("The buffers' contents is not identical!\n");
return 1;
}
/* Now we decode the values again using the XDS implementation and
compare them to our original values. Obviously, they should not
differ. */
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "float", &xdr_decode_float, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, xds_buf, xds_buf_size) != XDS_OK) {
printf("setbuffer() failed.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (float); ++i) {
float tmp;
if (xds_decode(xds, "float", &tmp) != XDS_OK) {
printf("xds_decode() failed for the %d value!\n", i);
return 1;
}
if (values[i] != tmp) {
printf("The %dth value has not been decoded correctly!\n", i);
return 1;
}
}
xds_destroy(xds);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_FLOAT */
#ifdef XDS_TEST_XDR_DOUBLE
int main(int argc, char *argv[])
{
XDR xdrs;
char xdr_buf[1024];
size_t xdr_buf_size;
xds_t *xds;
char *xds_buf;
size_t xds_buf_size;
double values[] =
{
0,
3.141592653,
-3.14159265,
0.14,
-0.14,
123456.789,
-123456.789
};
size_t i;
/* Encode the values array using the RPC-XDR implementation. */
xdrmem_create(&xdrs, xdr_buf, sizeof (xdr_buf), XDR_ENCODE);
for (i = 0; i < sizeof (values) / sizeof (double); ++i)
xdr_double(&xdrs, &values[i]);
xdr_buf_size = xdr_getpos(&xdrs);
xdr_destroy(&xdrs);
/* Encode the values array using the XDS implementation. */
if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "double", &xdr_encode_double, NULL) != XDS_OK) {
printf("Failed to register my encoding engines.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (double); ++i) {
if (xds_encode(xds, "double", values[i]) != XDS_OK) {
printf("xds_encode(values[%d]) failed!\n", i);
return 1;
}
}
if (xds_getbuffer(xds, XDS_GIFT, (void **)&xds_buf, &xds_buf_size) !=
XDS_OK) {
printf("getbuffer() failed.\n");
return 1;
}
xds_destroy(xds);
/* Both buffers must be equal now. */
if (xdr_buf_size != xds_buf_size) {
printf("The buffer sizes don't match: %d != %d.\n", xdr_buf_size,
xds_buf_size);
return 1;
}
if (memcmp(xds_buf, xdr_buf, xds_buf_size) != 0) {
printf("The buffers' contents is not identical!\n");
return 1;
}
/* Now we decode the values again using the XDS implementation and
compare them to our original values. Obviously, they should not
differ. */
if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
printf("Failed to initialize XDS context.\n");
return 1;
}
if (xds_register(xds, "double", &xdr_decode_double, NULL) != XDS_OK) {
printf("Failed to register my decoding engines.\n");
return 1;
}
if (xds_setbuffer(xds, XDS_GIFT, xds_buf, xds_buf_size) != XDS_OK) {
printf("setbuffer() failed.\n");
return 1;
}
for (i = 0; i < sizeof (values) / sizeof (double); ++i) {
double tmp;
if (xds_decode(xds, "double", &tmp) != XDS_OK) {
printf("xds_decode() failed for the %d value!\n", i);
return 1;
}
if (values[i] != tmp) {
printf("The %dth value has not been decoded correctly!\n", i);
return 1;
}
}
xds_destroy(xds);
/* Everything went fine. */
return 0;
}
#endif /* XDS_TEST_XDR_DOUBLE */
