head	1.14;
access;
symbols
	XDS_0_9_3:1.14
	XDS_0_9_2:1.14
	XDS_0_9_1:1.13
	XDS_0_9_0:1.12;
locks; strict;
comment	@ * @;


1.14
date	2005.06.02.18.51.44;	author rse;	state Exp;
branches;
next	1.13;

1.13
date	2004.09.12.17.32.14;	author rse;	state Exp;
branches;
next	1.12;

1.12
date	2003.02.17.12.36.02;	author rse;	state Exp;
branches;
next	1.11;

1.11
date	2003.02.17.12.27.51;	author rse;	state Exp;
branches;
next	1.10;

1.10
date	2002.03.17.10.25.53;	author rse;	state Exp;
branches;
next	1.9;

1.9
date	2002.01.02.17.13.45;	author rse;	state Exp;
branches;
next	1.8;

1.8
date	2001.08.30.10.31.55;	author simons;	state Exp;
branches;
next	1.7;

1.7
date	2001.08.30.08.55.41;	author simons;	state Exp;
branches;
next	1.6;

1.6
date	2001.08.22.20.22.41;	author simons;	state Exp;
branches;
next	1.5;

1.5
date	2001.08.13.19.48.02;	author rse;	state Exp;
branches;
next	1.4;

1.4
date	2001.08.12.11.31.45;	author rse;	state Exp;
branches;
next	1.3;

1.3
date	2001.08.09.20.59.05;	author rse;	state Exp;
branches;
next	1.2;

1.2
date	2001.08.09.19.58.35;	author rse;	state Exp;
branches;
next	1.1;

1.1
date	2001.08.08.19.15.23;	author rse;	state Exp;
branches;
next	;


desc
@@


1.14
log
@Bumped year in copyright messages for year 2005.
@
text
@/*
**  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 */
@


1.13
log
@Bumped year in copyright messages for year 2004.
@
text
@d3 3
a5 3
**  Copyright (c) 2001-2004 Ralf S. Engelschall <rse@@engelschall.com>
**  Copyright (c) 2001-2004 The OSSP Project <http://www.ossp.org/>
**  Copyright (c) 2001-2004 Cable & Wireless <http://www.cw.com/>
@


1.12
log
@upgrade to standard OSSP copyright and bump year to 2003
@
text
@d3 3
a5 3
**  Copyright (c) 2001-2003 Ralf S. Engelschall <rse@@engelschall.com>
**  Copyright (c) 2001-2003 The OSSP Project <http://www.ossp.org/>
**  Copyright (c) 2001-2003 Cable & Wireless Germany <http://www.cw.com/de/>
@


1.11
log
@cleanup API by returning xds_rc_t in xds_init, too
@
text
@d3 3
a5 2
**  Copyright (c) 2001-2002 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001-2002 Cable & Wireless Deutschland (http://www.cw.com/de/)
@


1.10
log
@update texts
@
text
@d69 1
a69 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d104 1
a104 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d172 1
a172 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d207 1
a207 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d271 1
a271 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d306 1
a306 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d378 1
a378 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d413 1
a413 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d459 1
a459 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d482 1
a482 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d528 1
a528 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d551 1
a551 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d594 1
a594 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d618 1
a618 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d665 1
a665 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d688 1
a688 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d754 1
a754 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d789 1
a789 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d853 1
a853 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d888 1
a888 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
@


1.9
log
@bump copyright year
@
text
@d2 1
a2 1
**  XDS - OSSP Extensible Data Serialization Library
d6 2
a7 2
**  This file is part of OSSP XDS, an extensible data serialization
**  library which can be found at http://www.ossp.org/pkg/xds/.
@


1.8
log
@Use longer numbers for the double test.
@
text
@d3 2
a4 2
**  Copyright (c) 2001 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001 Cable & Wireless Deutschland (http://www.cw.com/de/)
@


1.7
log
@Added test suite for double types.
@
text
@d853 2
a854 2
	3.14,
	-3.14,
@


1.6
log
@Added test suite for float encoding/decoding.
@
text
@d837 101
@


1.5
log
@Remove trailing whitespaces on all non-generated files.
@
text
@d737 100
@


1.4
log
@Hhmm... who has introduced ossp.com?!
Our project's domain is ossp.org, of course.
@
text
@d347 1
a347 1
#ifdef XDS_HAVE_64_BIT_SUPPORT 
@


1.3
log
@Final adjustments to coding style in order to make OSSP XDS look equal
in style to all other OSSP parts. This should remove most of the
strangeness GNU indent usually introduces.
@
text
@d7 1
a7 1
**  library which can be found at http://www.ossp.com/pkg/xds/.
@


1.2
log
@Use the license consistently.
@
text
@d40 1
a40 1
int main()
a61 1

a68 1

a91 1

d103 2
a104 3
     * compare them to our original values. Obviously, they should not
     * differ. */

a131 1

d140 1
a140 1
static int xdr_uint32_t(XDR * xdrs, uint32_t * val)
d146 1
a146 1
int main()
a166 1

a173 1

a196 1

d208 2
a209 3
     * compare them to our original values. Obviously, they should not
     * differ. */

a236 1

d246 1
a246 1
int main()
a267 1

a274 1

a297 1

d309 2
a310 3
     * compare them to our original values. Obviously, they should not
     * differ. */

a337 1

d350 1
a350 1
static int xdr_uint64_t(XDR * xdrs, uint64_t * val)
d356 1
a356 1
int main()
a376 1

a383 1

a406 1

d418 2
a419 3
     * compare them to our original values. Obviously, they should not
     * differ. */

a446 1

d456 1
a456 1
int main()
d466 1
a466 2
     * the string back, verifying that it hasn't changed. */

a519 1

d527 1
a527 1
int main()
d537 1
a537 2
     * the string back, verifying that it hasn't changed. */

a586 1

d594 1
a594 1
int main()
d605 1
a605 2
     * the string back, verifying that it hasn't changed. */

a659 1

d667 1
a667 1
int main()
d678 1
a678 2
     * the string back, verifying that it hasn't changed. */

d699 1
a699 2
        printf
            ("The encoded octet stream's buffer size is not a multiple of 4.\n");
a731 1

d736 1
@


1.1
log
@First cut of the ruthless style adjustments to OSSP XDS:

o adjust source tree to follow OSSP source tree style
  by heavily combining sources into smaller sets
  (needs more work when still missing parts are added later)

o automatic re-indentation of sources with GNU indent
  (still needs manual review and adjustments; will follow)

These two heavy steps were mostly done automatically with the help of
two helper scripts written in Perl. So expect more manual adjustments to
follow...
@
text
@d1 28
a28 23
/* 
 * XDS - OSSP Extensible Data Serialization Library Copyright (c) 2001 The
 * OSSP Project (http://www.ossp.org/) Copyright (c) 2001 Cable & Wireless
 * Deutschland (http://www.cw.com/de/)
 * 
 * This file is part of OSSP XDS, an extensible data serialization library
 * which can be found at http://www.ossp.com/pkg/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. */
@