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

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: }