Return to chardata.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / tests

Annotation of embedaddon/expat/tests/chardata.c, revision 1.1

1.1     ! misho       1: /* Copyright (c) 1998-2003 Thai Open Source Software Center Ltd
        !             2:    See the file COPYING for copying permission.
        !             3: 
        !             4:    chardata.c
        !             5: */
        !             6: 
        !             7: #ifdef HAVE_EXPAT_CONFIG_H
        !             8: #include <expat_config.h>
        !             9: #endif
        !            10: #ifdef HAVE_CHECK_H
        !            11: #include <check.h>
        !            12: #else
        !            13: #include "minicheck.h"
        !            14: #endif
        !            15: 
        !            16: #include <assert.h>
        !            17: #include <stdio.h>
        !            18: #include <string.h>
        !            19: 
        !            20: #include "chardata.h"
        !            21: 
        !            22: 
        !            23: static int
        !            24: xmlstrlen(const XML_Char *s)
        !            25: {
        !            26:     int len = 0;
        !            27:     assert(s != NULL);
        !            28:     while (s[len] != 0)
        !            29:         ++len;
        !            30:     return len;
        !            31: }
        !            32: 
        !            33: 
        !            34: void
        !            35: CharData_Init(CharData *storage)
        !            36: {
        !            37:     assert(storage != NULL);
        !            38:     storage->count = -1;
        !            39: }
        !            40: 
        !            41: void
        !            42: CharData_AppendString(CharData *storage, const char *s)
        !            43: {
        !            44:     int maxchars = sizeof(storage->data) / sizeof(storage->data[0]);
        !            45:     int len;
        !            46: 
        !            47:     assert(s != NULL);
        !            48:     len = strlen(s);
        !            49:     if (storage->count < 0)
        !            50:         storage->count = 0;
        !            51:     if ((len + storage->count) > maxchars) {
        !            52:         len = (maxchars - storage->count);
        !            53:     }
        !            54:     if (len + storage->count < sizeof(storage->data)) {
        !            55:         memcpy(storage->data + storage->count, s, len);
        !            56:         storage->count += len;
        !            57:     }
        !            58: }
        !            59: 
        !            60: void
        !            61: CharData_AppendXMLChars(CharData *storage, const XML_Char *s, int len)
        !            62: {
        !            63:     int maxchars;
        !            64: 
        !            65:     assert(storage != NULL);
        !            66:     assert(s != NULL);
        !            67:     maxchars = sizeof(storage->data) / sizeof(storage->data[0]);
        !            68:     if (storage->count < 0)
        !            69:         storage->count = 0;
        !            70:     if (len < 0)
        !            71:         len = xmlstrlen(s);
        !            72:     if ((len + storage->count) > maxchars) {
        !            73:         len = (maxchars - storage->count);
        !            74:     }
        !            75:     if (len + storage->count < sizeof(storage->data)) {
        !            76:         memcpy(storage->data + storage->count, s,
        !            77:                len * sizeof(storage->data[0]));
        !            78:         storage->count += len;
        !            79:     }
        !            80: }
        !            81: 
        !            82: int
        !            83: CharData_CheckString(CharData *storage, const char *expected)
        !            84: {
        !            85:     char buffer[1280];
        !            86:     int len;
        !            87:     int count;
        !            88: 
        !            89:     assert(storage != NULL);
        !            90:     assert(expected != NULL);
        !            91:     count = (storage->count < 0) ? 0 : storage->count;
        !            92:     len = strlen(expected);
        !            93:     if (len != count) {
        !            94:         if (sizeof(XML_Char) == 1)
        !            95:             sprintf(buffer, "wrong number of data characters:"
        !            96:                     " got %d, expected %d:\n%s", count, len, storage->data);
        !            97:         else
        !            98:             sprintf(buffer,
        !            99:                     "wrong number of data characters: got %d, expected %d",
        !           100:                     count, len);
        !           101:         fail(buffer);
        !           102:         return 0;
        !           103:     }
        !           104:     if (memcmp(expected, storage->data, len) != 0) {
        !           105:         fail("got bad data bytes");
        !           106:         return 0;
        !           107:     }
        !           108:     return 1;
        !           109: }
        !           110: 
        !           111: int
        !           112: CharData_CheckXMLChars(CharData *storage, const XML_Char *expected)
        !           113: {
        !           114:     char buffer[1024];
        !           115:     int len = xmlstrlen(expected);
        !           116:     int count;
        !           117: 
        !           118:     assert(storage != NULL);
        !           119:     count = (storage->count < 0) ? 0 : storage->count;
        !           120:     if (len != count) {
        !           121:         sprintf(buffer, "wrong number of data characters: got %d, expected %d",
        !           122:                 count, len);
        !           123:         fail(buffer);
        !           124:         return 0;
        !           125:     }
        !           126:     if (memcmp(expected, storage->data, len * sizeof(storage->data[0])) != 0) {
        !           127:         fail("got bad data bytes");
        !           128:         return 0;
        !           129:     }
        !           130:     return 1;
        !           131: }