head	1.12;
access;
symbols
	XDS_0_9_3:1.12
	XDS_0_9_2:1.12
	XDS_0_9_1:1.11
	XDS_0_9_0:1.10;
locks; strict;
comment	@ * @;


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

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

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

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

1.8
date	2002.03.17.10.25.53;	author rse;	state Exp;
branches;
next	1.7;

1.7
date	2002.01.02.17.13.45;	author rse;	state Exp;
branches;
next	1.6;

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

1.5
date	2001.08.30.10.42.24;	author simons;	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.12
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_xml.c: test suite for XML encodig/decoding engine
*/

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "xds_p.h"

#ifdef XDS_TEST_XML_INT32

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    xds_int32_t values[] = {
        0x00000000,
        0x12345678,
        -0x12345678,
        0x7bcdef01,
        -0x7bcdef01,
        0x7fffffff
    };

    size_t i;

    /* Encode the values array, then decode it back and compare the numbers. */
    if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK ||
        xds_register(xds, "int", &xml_encode_int32, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin") != XDS_OK) {
        printf("xds_encode_begin() failed!\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_encode(xds, "end") != XDS_OK) {
        printf("xds_encode_end() failed!\n");
        return 1;
    }
    if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) !=
        XDS_OK) {
        printf("getbuffer() failed.\n");
        return 1;
    }
    xds_destroy(xds);

    if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_decode_end, NULL) != XDS_OK ||
        xds_register(xds, "int", &xml_decode_int32, 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("setbuffer() failed.\n");
        return 1;
    }
    if (xds_decode(xds, "begin") != XDS_OK) {
        printf("xds_decode_begin() failed!\n");
        return 1;
    }
    for (i = 0; i < sizeof (values) / sizeof (xds_int32_t); ++i) {
        xds_int32_t val;
        if (xds_decode(xds, "int", &val) != XDS_OK) {
            printf("xds_decode(values[%d]) failed!\n", i);
            return 1;
        }
        if (val != values[i]) {
            printf
                ("Decoded value (%d) does not match the original value (%d)!\n",
                 val, values[i]);
            return 1;
        }
    }
    if (xds_decode(xds, "end") != XDS_OK) {
        printf("xds_decode_end() failed!\n");
        return 1;
    }
    xds_destroy(xds);

    /* Everything went fine. */
    return 0;
}

#endif /* XDS_TEST_XML_INT32 */

#ifdef XDS_TEST_XML_UINT32

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    xds_uint32_t values[] = {
        0x00000000,
        0x12345678,
        0xabcdef01,
        0xc500b3ef,
        0xffffffff
    };

    size_t i;

    /* Encode the values array, then decode it back and compare the numbers. */
    if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "int", &xml_encode_uint32, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    for (i = 0; i < sizeof (values) / sizeof (xds_uint32_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 **)&buffer, &buffer_size) !=
        XDS_OK) {
        printf("getbuffer() failed.\n");
        return 1;
    }
    xds_destroy(xds);

    if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "int", &xml_decode_uint32, 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("setbuffer() failed.\n");
        return 1;
    }
    for (i = 0; i < sizeof (values) / sizeof (xds_uint32_t); ++i) {
        xds_uint32_t val;
        if (xds_decode(xds, "int", &val) != XDS_OK) {
            printf("xds_decode(values[%d]) failed!\n", i);
            return 1;
        }
        if (val != values[i]) {
            printf
                ("Decoded value (%d) does not match the original value (%d)!\n",
                 val, values[i]);
            return 1;
        }
    }
    xds_destroy(xds);

    /* Everything went fine. */
    return 0;
}

#endif /* XDS_TEST_XML_UINT32 */

#ifdef XDS_TEST_XML_INT64

#ifdef XDS_HAVE_64_BIT_SUPPORT

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    xds_int64_t values[] = {
        0x0000000000000000LL,
        0x123456789abcdef0LL,
        -0x123456789abcdef0LL,
        0x7bcdef01cc45bb9aLL,
        -0x7bcdef01cc45bb9aLL,
        0x7fffffffffffffffLL
    };

    size_t i;

    /* Encode the values array, then decode it back and compare the numbers. */
    if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "int", &xml_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 **)&buffer, &buffer_size) !=
        XDS_OK) {
        printf("getbuffer() failed.\n");
        return 1;
    }
    xds_destroy(xds);

    if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "int", &xml_decode_int64, 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("setbuffer() failed.\n");
        return 1;
    }
    for (i = 0; i < sizeof (values) / sizeof (xds_int64_t); ++i) {
        xds_int64_t val;
        if (xds_decode(xds, "int", &val) != XDS_OK) {
            printf("xds_decode(values[%d]) failed!\n", i);
            return 1;
        }
        if (val != values[i]) {
            printf("Decoded value does not match the original!\n");
            return 1;
        }
    }
    xds_destroy(xds);

    /* Everything went fine. */
    return 0;
}

#endif /* XDS_HAVE_64_BIT_SUPPORT */

#endif /* XDS_TEST_XML_INT64 */

#ifdef XDS_TEST_XML_UINT64

#ifdef XDS_HAVE_64_BIT_SUPPORT

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    xds_uint64_t values[] = {
        0x0000000000000000ULL,
        0x123456789abcdef0ULL,
        0xabcdef01cc45bb9aULL,
        0xc500b3efdd34ca9eULL,
        0xffffffffffffffffULL
    };

    size_t i;

    /* Encode the values array, then decode it back and compare the numbers. */
    if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "int", &xml_encode_uint64, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    for (i = 0; i < sizeof (values) / sizeof (xds_uint64_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 **)&buffer, &buffer_size) !=
        XDS_OK) {
        printf("getbuffer() failed.\n");
        return 1;
    }
    xds_destroy(xds);

    if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "int", &xml_decode_uint64, 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("setbuffer() failed.\n");
        return 1;
    }
    for (i = 0; i < sizeof (values) / sizeof (xds_uint64_t); ++i) {
        xds_uint64_t val;
        if (xds_decode(xds, "int", &val) != XDS_OK) {
            printf("xds_decode(values[%d]) failed!\n", i);
            return 1;
        }
        if (val != values[i]) {
            printf("Decoded value does not match the original!\n");
            return 1;
        }
    }
    xds_destroy(xds);

    /* Everything went fine. */
    return 0;
}

#endif /* XDS_HAVE_64_BIT_SUPPORT */

#endif /* XDS_TEST_XML_UINT64 */

#ifdef XDS_TEST_XML_DOUBLE

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    xds_double_t values[] = {
        0.0,
        -0.0,
        3.141592,
        -3.141592,
        298473.141592,
        -298473.141592
    };

    size_t i;

    /* Encode the values array, then decode it back and compare the numbers. */

    if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
	xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK ||
	xds_register(xds, "double", &xml_encode_double, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin") != XDS_OK)
	{
	printf("xds_encode_begin() failed!\n");
	return 1;
	}
    for (i = 0; i < sizeof (values) / sizeof (xds_double_t); ++i)
	{
        if (xds_encode(xds, "double", values[i]) != XDS_OK)
	    {
            printf("xds_encode(values[%d]) failed!\n", i);
            return 1;
	    }
	}
    if (xds_encode(xds, "end") != XDS_OK)
	{
	printf("xds_encode_end() failed!\n");
	return 1;
	}
    if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) != XDS_OK)
	{
        printf("getbuffer() failed.\n");
        return 1;
	}
    xds_destroy(xds);

    if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
	xds_register(xds, "end", &xml_decode_end, NULL) != XDS_OK ||
	xds_register(xds, "double", &xml_decode_double, 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("setbuffer() failed.\n");
        return 1;
    }
    if (xds_decode(xds, "begin") != XDS_OK)
	{
	printf("xds_decode_begin() failed!\n");
	return 1;
	}
    for (i = 0; i < sizeof (values) / sizeof (xds_double_t); ++i) {
        xds_double_t val;
        if (xds_decode(xds, "double", &val) != XDS_OK) {
            printf("xds_decode(values[%d]) failed!\n", i);
            return 1;
        }
        if (val != values[i]) {
	    printf("Decoding the %dth value failed!\n", i);
            return 1;
        }
    }
    if (xds_decode(xds, "end") != XDS_OK)
	{
	printf("xds_decode_end() failed!\n");
	return 1;
	}
    xds_destroy(xds);

    /* Everything went fine. */

    return 0;
}

#endif /* XDS_TEST_XML_DOUBLE */

#ifdef XDS_TEST_XML_FLOAT

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    xds_float_t values[] = {
        0.0,
        -0.0,
        3.141592,
        -3.141592,
        298473.141592,
        -298473.141592
    };

    size_t i;

    /* Encode the values array, then decode it back and compare the numbers. */

    if (xds_init(&xds, XDS_ENCODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
	xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK ||
	xds_register(xds, "float", &xml_encode_float, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin") != XDS_OK)
	{
	printf("xds_encode_begin() failed!\n");
	return 1;
	}
    for (i = 0; i < sizeof (values) / sizeof (xds_float_t); ++i)
	{
        if (xds_encode(xds, "float", values[i]) != XDS_OK)
	    {
            printf("xds_encode(values[%d]) failed!\n", i);
            return 1;
	    }
	}
    if (xds_encode(xds, "end") != XDS_OK)
	{
	printf("xds_encode_end() failed!\n");
	return 1;
	}
    if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) != XDS_OK)
	{
        printf("getbuffer() failed.\n");
        return 1;
	}
    xds_destroy(xds);

    if (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
	xds_register(xds, "end", &xml_decode_end, NULL) != XDS_OK ||
	xds_register(xds, "float", &xml_decode_float, 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("setbuffer() failed.\n");
        return 1;
    }
    if (xds_decode(xds, "begin") != XDS_OK)
	{
	printf("xds_decode_begin() failed!\n");
	return 1;
	}
    for (i = 0; i < sizeof (values) / sizeof (xds_float_t); ++i) {
        xds_float_t val;
        if (xds_decode(xds, "float", &val) != XDS_OK) {
            printf("xds_decode(values[%d]) failed!\n", i);
            return 1;
        }
        if (val != values[i]) {
	    printf("Decoding the %dth value failed!\n", i);
            return 1;
        }
    }
    if (xds_decode(xds, "end") != XDS_OK)
	{
	printf("xds_decode_end() failed!\n");
	return 1;
	}
    xds_destroy(xds);

    /* Everything went fine. */

    return 0;
}

#endif /* XDS_TEST_XML_FLOAT */

#ifdef XDS_TEST_XML_STRING

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    char msg[] = "<Hallo> ]]>&<&>World: äöüß";
    char *new_msg;

    /* Encode the string, 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", &xml_encode_string, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin string end", 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 (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "string", &xml_decode_string, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_decode_end, 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, "begin string end", &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_XML_STRING */

#ifdef XDS_TEST_XML_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, 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", &xml_encode_string, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin string end", 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 (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "string", &xml_decode_string, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_decode_end, 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, "begin string end", &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_XML_STRING_EMPTY */

#ifdef XDS_TEST_XML_OCTETSTREAM

int main(int argc, char *argv[])
{
    xds_t *xds;
    char *buffer;
    size_t buffer_size;

    char msg[] = "Hallo\000Worl";
    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", &xml_encode_octetstream, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin os end", 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 (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "os", &xml_decode_octetstream, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_decode_end, 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, "begin os end", &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_XML_OCTETSTREAM */

#ifdef XDS_TEST_XML_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", &xml_encode_octetstream, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_encode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_encode_end, NULL) != XDS_OK) {
        printf("Failed to register my encoding engines.\n");
        return 1;
    }
    if (xds_encode(xds, "begin os end", 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 (xds_init(&xds, XDS_DECODE) != XDS_OK) {
        printf("Failed to initialize XDS context.\n");
        return 1;
    }
    if (xds_register(xds, "os", &xml_decode_octetstream, NULL) != XDS_OK ||
        xds_register(xds, "begin", &xml_decode_begin, NULL) != XDS_OK ||
        xds_register(xds, "end", &xml_decode_end, 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, "begin os end", &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_XML_OCTETSTREAM_EMPTY */
@


1.11
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.10
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.9
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.8
log
@update texts
@
text
@d56 1
a56 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d87 1
a87 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d149 1
a149 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d170 1
a170 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d225 1
a225 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d246 1
a246 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d300 1
a300 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d321 1
a321 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d375 1
a375 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d410 1
a410 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d475 1
a475 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d510 1
a510 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d567 1
a567 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d588 1
a588 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d636 1
a636 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d657 1
a657 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d706 1
a706 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d727 1
a727 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
d776 1
a776 2
    xds = xds_init(XDS_ENCODE);
    if (xds == NULL) {
d797 1
a797 2
    xds = xds_init(XDS_DECODE);
    if (xds == NULL) {
@


1.7
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.6
log
@- Activated the old test for XML-encoding of doubles.
- Added a new test for XML-encoding of floats.
@
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.5
log
@Removed unnecessary debug output.
@
text
@a365 1
#if 0
d371 6
a376 1
        3.14159265358979323844
d388 3
a390 1
    if (xds_register(xds, "int", &xml_encode_double, NULL) != XDS_OK) {
d394 9
a402 2
    for (i = 0; i < sizeof (values) / sizeof (xds_double_t); ++i) {
        if (xds_encode(xds, "int", values[i]) != XDS_OK) {
d405 9
a413 4
        }
    }
    if (xds_getbuffer(xds, XDS_GIFT, (void **)&buffer, &buffer_size) !=
        XDS_OK) {
d416 1
a416 1
    }
a418 2
    printf("%s\n", buffer);

d424 3
a426 1
    if (xds_register(xds, "int", &xml_decode_double, NULL) != XDS_OK) {
d434 5
d441 1
a441 1
        if (xds_decode(xds, "int", &val) != XDS_OK) {
d446 1
a446 3
            printf
                ("Decoded value (%E) does not match the original value (%E)!\n",
                 val, values[i]);
d450 5
d458 1
a458 1
#endif
d464 102
a850 1

@


1.4
log
@Hhmm... who has introduced ossp.com?!
Our project's domain is ossp.org, of course.
@
text
@a471 2
    write(1, buffer, buffer_size);
    printf("\n");
a542 2
    write(1, buffer, buffer_size);
    printf("\n");
a614 2
    write(1, buffer, buffer_size);
    printf("\n");
a686 2
    write(1, buffer, buffer_size);
    printf("\n");
@


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
@d38 1
a38 1
int main()
a55 1

a126 1

d134 1
a134 1
int main()
a150 1

a201 1

d211 1
a211 1
int main()
a228 1

a277 1

d289 1
a289 1
int main()
a305 1

a354 1

d364 1
a364 1
int main()
d440 1
a440 1
int main()
d450 1
a450 2
     * verifying that it hasn't changed. */

a505 1

d513 1
a513 1
int main()
d523 1
a523 2
     * verifying that it hasn't changed. */

a578 1

d586 1
a586 1
int main()
d597 1
a597 2
     * the string back, verifying that it hasn't changed. */

a652 1

d660 1
a660 1
int main()
d671 1
a671 2
     * the string back, verifying that it hasn't changed. */

a726 1

d731 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. */
@