static errorCode sample_intData(Integer int_val, void* app_data)
{
appData* appD = (appData*) app_data;
/* char tmp_buf[30]; */
if(appD->expectAttributeData)
{
asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE);
/*
sprintf(tmp_buf, "%lld", int_val);
printf("%s", tmp_buf);
printf("\"\n");
*/
appD->expectAttributeData = 0;
}
else
{
asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE);
/*
sprintf(tmp_buf, "%lld", int_val);
printf("%s", tmp_buf);
printf("\n");
*/
}
return EXIP_OK;
}
static errorCode sample_floatData(Float fl_val, void* app_data)
{
appData* appD = (appData*) app_data;
/* char tmp_buf[30]; */
if(appD->expectAttributeData)
{
asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE);
/*
sprintf(tmp_buf, "%lldE%d", fl_val.mantissa, fl_val.exponent);
printf("%s", tmp_buf);
printf("\"\n");
*/
appD->expectAttributeData = 0;
}
else
{
asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE);
/*
printf("%3d CH ", appD->eventCount);
sprintf(tmp_buf, "%lldE%d", fl_val.mantissa, fl_val.exponent);
printf("%s", tmp_buf);
printf("\n");
*/
}
return EXIP_OK;
}
/**
* @brief Create a File Writer (libxml2 compatibility function)
* @param uri Filename
* @param compression Unused
* @return A xmlTextWriterPtr object
*/
static xmlTextWriterPtr xmlNewTextWriterFilename(const char *uri, int compression, char *schemaID) {
EXIStream *stream;
xmlBufferPtr buf = xmlBufferCreate();
FILE *outfile = fopen(uri, "wb" );
if(!outfile)
return NULL;
stream = calloc(sizeof(EXIStream), 1);
// I: First initialize the header of the stream
serialize.initHeader(stream);
// II: Set any options in the header, if different from the defaults
//stream->header.has_cookie = TRUE;
stream->header.has_options = TRUE;
//stream->header.opts.valueMaxLength = 300;
//stream->header.opts.valuePartitionCapacity = 50;
// SET_STRICT(stream->header.opts.enumOpt);
SET_PRESERVED(stream->header.opts.preserve, PRESERVE_PREFIXES);
// SET_ALIGNMENT(stream->header.opts.enumOpt, BYTE_ALIGNMENT);
// III: Define an external stream for the output if any
buf->ioStrm.readWriteToStream = writeFileOutputStream;
buf->ioStrm.stream = outfile;
// IV: Initialize the stream
#if EXIP_VERSION==276
if (schemaID && *schemaID) {
XoExiLoadSchema (schemaID);
String s;
asciiToString(schemaID, &s, &stream->memList, FALSE);
serialize.initStream(stream, *buf, g_schemaPtr, SCHEMA_ID_SET, &s);
}
else {
serialize.initStream(stream, *buf, g_schemaPtr, SCHEMA_ID_ABSENT, NULL);
}
#endif
#if EXIP_VERSION>=289
if (schemaID && *schemaID) {
XoExiLoadSchema (schemaID);
asciiToString(schemaID, &stream->header.opts.schemaID, &stream->memList, FALSE);
stream->header.opts.schemaIDMode = SCHEMA_ID_SET;
}
else {
stream->header.opts.schemaIDMode = SCHEMA_ID_ABSENT;
}
serialize.initStream(stream, *buf, g_schemaPtr);
#endif
// V: Start building the stream step by step: header, document, element etc...
serialize.exiHeader(stream);
return (xmlTextWriterPtr)stream;
}
void serializeXSITYPE(EXIStream *strm, char *value) {
char s_uri[100], s_ln[100];
String uri;
String ln;
QName qxsi = {&uri,&ln};
PRINT ("serialize.qnameData %s\n", value);
cutQName (value, s_uri, s_ln);
asciiToString(s_uri, &uri, &strm->memList, FALSE);
asciiToString(s_ln, &ln, &strm->memList, FALSE);
serialize.qnameData(strm, qxsi);
}
static errorCode sample_endElement(void* app_data)
{
appData* appD = (appData*) app_data;
asciiToString("EE", &appD->eventCode, &appD->allocList, TRUE);
return EXIP_OK;
}
static errorCode sample_decimalData(Decimal value, void* app_data)
{
appData* appD = (appData*) app_data;
if(appD->expectAttributeData)
{
asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE);
/*
printf("%.1f\"\n", (double) value);
*/
appD->expectAttributeData = 0;
}
else
{
asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE);
}
return EXIP_OK;
}
static errorCode sample_startElement(QName qname, void* app_data)
{
appData* appD = (appData*) app_data;
asciiToString("SE", &appD->eventCode, &appD->allocList, TRUE);
cloneStringManaged(qname.uri, &appD->uri, &appD->allocList);
cloneStringManaged(qname.localName, &appD->localName, &appD->allocList);
return EXIP_OK;
}
static errorCode sample_stringData(const String value, void* app_data)
{
appData* appD = (appData*) app_data;
if(appD->expectAttributeData)
{
asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE);
/*
printString(&value);
printf("\"\n");
*/
appD->expectAttributeData = 0;
}
else
{
asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE);
/*
printString(&value);
printf("\n");
*/
}
return EXIP_OK;
}
static errorCode sample_attribute(QName qname, void* app_data)
{
appData* appD = (appData*) app_data;
asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE);
/*
printString(qname.uri);
printf(" ");
printString(qname.localName);
printf("=\"");
*/
appD->expectAttributeData = 1;
return EXIP_OK;
}
/**
* @brief Writes a string as an element's content (libxml2 compatibility function)
* @param writer An EXIStream
* @param content String
* @return 0 if success, -1 if error
*/
static int xmlTextWriterWriteString(xmlTextWriterPtr writer, const xmlChar *content) {
int ret = 0;
PRINT ("CH [%s] (%d)\n", (char *)content, strlen((char *)content));
if (g_schemaPtr) {
String uri = {NULL,0};
String localName = {NULL,0};
QName qname = {&uri, &localName, NULL };
ret = ExiSerialize(writer, qname, (char *)content, FALSE, currentContext()->valueType);
}
else
{
String chVal;
ret += asciiToString((char *)content, &chVal, &writer->memList, FALSE);
PRINT ("serialize.stringData (%s)\n", (char *)content);
ret += serialize.stringData(writer, chVal);
}
if (ret) return -1;
return 0;
}
void loadEffectsFromHost(void)
{
initializeEffects();
uartInit();
char received[500];
for (int i = 0; i < 500; ++i)
{
received[i] = '\0';
}
int write = 0;
bool done = _FALSE;
while ((!done) && (write < 500))
{
while (!uartIsDataReady())
;
received[write] = uartRead();
if (received[write] == ESCAPE_MESSAGE_END)
{
done = _TRUE;
}
write++;
}
if (write > 500)
{
error("Received message is over 500 characters and contains no ESCAPE_MESSAGE_END character.");
}
int read = 0;
int effect_idx = 0;
while ((read < write) && (received[read] != ESCAPE_MESSAGE_END))
{
// First comes the effect's name
effects[effect_idx].in_use = _TRUE;
asciiToString(received, &read, effects[effect_idx].name, EFFECT_NAME_LENGTH);
// We're now at the parameters
int param_idx = 0;
while (received[read] != ESCAPE_EFFECT_END)
{
// Parameter name
asciiToString(received, &read, effects[effect_idx].params[param_idx].name, PARAM_NAME_LENGTH);
// Parameter values, in order: min - regular - max
effects[effect_idx].params[param_idx].min = asciiToInt2d(received, &read);
effects[effect_idx].params[param_idx].regular = asciiToInt2d(received, &read);
effects[effect_idx].params[param_idx].max = asciiToInt2d(received, &read);
// Each parameters starts set at the regular value
effects[effect_idx].params[param_idx].current = effects[effect_idx].params[param_idx].regular;
effects[effect_idx].params[param_idx].in_use = _TRUE;
param_idx++;
// We're now at the next parameter (or next effect, or message ending)
}
effect_idx++;
read++; // Advance to the next effect (or message ending)
}
numLoadedEffects = effect_idx;
}
int main(int argc, char *argv[])
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
FILE *outfile;
char sourceFile[50];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
if(argc > 1)
{
if(strcmp(argv[1], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strcmp(argv[1], "-schema") == 0)
{
FILE *schemaFile;
BinaryBuffer buffer[MAX_XSD_FILES_COUNT]; // up to 10 XSD files
char schemaFileName[50];
unsigned int schemaFilesCount = 0;
unsigned int i;
if(argc <= 3)
{
printfHelp();
return 0;
}
else
schemaFilesCount = argc - 3;
if(schemaFilesCount > MAX_XSD_FILES_COUNT)
{
fprintf(stderr, "Too many xsd files given as an input: %d", schemaFilesCount);
exit(1);
}
for(i = 0; i < schemaFilesCount; i++)
{
strcpy(schemaFileName, argv[2 + i]);
schemaFile = fopen(schemaFileName, "rb" );
if(!schemaFile)
{
fprintf(stderr, "Unable to open file %s", schemaFileName);
return 1;
}
else
{
//Get file length
fseek(schemaFile, 0, SEEK_END);
buffer[i].bufLen = ftell(schemaFile) + 1;
fseek(schemaFile, 0, SEEK_SET);
//Allocate memory
buffer[i].buf = (char *) malloc(buffer[i].bufLen);
if (!buffer[i].buf)
{
fprintf(stderr, "Memory allocation error!");
fclose(schemaFile);
return 1;
}
//Read file contents into buffer
fread(buffer[i].buf, buffer[i].bufLen, 1, schemaFile);
fclose(schemaFile);
buffer[i].bufContent = buffer[i].bufLen;
buffer[i].ioStrm.readWriteToStream = NULL;
buffer[i].ioStrm.stream = NULL;
}
}
tmp_err_code = generateSchemaInformedGrammars(buffer, schemaFilesCount, SCHEMA_FORMAT_XSD_EXI, &schema);
if(tmp_err_code != ERR_OK)
{
printf("\n Error occured: %d", tmp_err_code);
return 1;
}
schemaPtr = &schema;
for(i = 0; i < schemaFilesCount; i++)
{
free(buffer[i].buf);
}
}
strcpy(sourceFile, argv[argc - 1]);
outfile = fopen(sourceFile, "wb" );
if(!outfile)
{
fprintf(stderr, "Unable to open file %s", sourceFile);
return 1;
}
else
{
EXIStream testStrm;
String uri;
String ln;
QName qname = {&uri, &ln, NULL};
String chVal;
char buf[OUTPUT_BUFFER_SIZE];
BinaryBuffer buffer;
buffer.buf = buf;
buffer.bufLen = OUTPUT_BUFFER_SIZE;
buffer.bufContent = 0;
// Serialization steps:
// I: First initialize the header of the stream
serialize.initHeader(&testStrm);
// II: Set any options in the header, if different from the defaults
testStrm.header.has_cookie = TRUE;
testStrm.header.has_options = TRUE;
testStrm.header.opts.valueMaxLength = 300;
testStrm.header.opts.valuePartitionCapacity = 50;
SET_STRICT(testStrm.header.opts.enumOpt);
// III: Define an external stream for the output if any
buffer.ioStrm.readWriteToStream = writeFileOutputStream;
buffer.ioStrm.stream = outfile;
// IV: Initialize the stream
tmp_err_code = serialize.initStream(&testStrm, buffer, schemaPtr, SCHEMA_ID_ABSENT, NULL);
if(tmp_err_code != ERR_OK)
printError(tmp_err_code, &testStrm, outfile);
// V: Start building the stream step by step: header, document, element etc...
tmp_err_code += serialize.exiHeader(&testStrm);
tmp_err_code += serialize.startDocument(&testStrm);
qname.uri = &NS_STR;
qname.localName = &ELEM_MULT_TEST_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <MultipleXSDsTest>
qname.uri = &NS_STR;
qname.localName = &ELEM_ENCODE_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <EXIPEncoder>
// NOTE: attributes should come lexicographically sorted during serialization
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_BYTE_STR;
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_SMALL_INTEGER); // testByte="
tmp_err_code += serialize.intData(&testStrm, 55);
}
else
{
// schema-less mode
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // testByte="
tmp_err_code += asciiToString("55", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
qname.localName = &ATTR_VERSION_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // version="
tmp_err_code += asciiToString("0.2", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += asciiToString("This is an example of serializing EXI streams using EXIP low level API", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </EXIPEncoder>
qname.uri = &NS_STR;
qname.localName = &ELEM_DESCR_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <description>
tmp_err_code += asciiToString("This is a test of processing XML schemes with multiple XSD files", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </description>
qname.uri = &NS_NESTED_STR;
qname.localName = &ELEM_TEST_SETUP_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <testSetup>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_GOAL_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // goal="
tmp_err_code += asciiToString("Verify that the implementation works!", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += asciiToString("Simple test element with single attribute", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </testSetup>
qname.uri = &NS_STR;
qname.localName = &ELEM_TYPE_TEST_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <type-test>
if(schemaPtr != NULL)
{
// schema mode
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_ID_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_INTEGER); // id="
tmp_err_code += serialize.intData(&testStrm, 1001);
}
else
{
// schema-less mode
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_ID_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // id="
tmp_err_code += asciiToString("1001", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
qname.uri = &NS_NESTED_STR;
qname.localName = &ELEM_BOOL_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <bool>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.booleanData(&testStrm, TRUE);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("true", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </bool>
tmp_err_code += serialize.endElement(&testStrm); // </type-test>
qname.uri = &NS_STR;
qname.localName = &ELEM_EXT_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <extendedTypeTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_BYTE_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <byteTest>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.intData(&testStrm, 11);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("11", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </byteTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_DATE_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <dateTimeTest>
if(schemaPtr != NULL)
{
// schema mode
EXIPDateTime dt;
dt.presenceMask = 0;
dt.presenceMask = dt.presenceMask | YEAR_PRESENCE;
dt.presenceMask = dt.presenceMask | MON_PRESENCE;
dt.presenceMask = dt.presenceMask | MDAY_PRESENCE;
dt.presenceMask = dt.presenceMask | HOUR_PRESENCE;
dt.presenceMask = dt.presenceMask | MIN_PRESENCE;
dt.presenceMask = dt.presenceMask | SEC_PRESENCE;
dt.presenceMask = dt.presenceMask | FRACT_PRESENCE;
dt.dateTime.tm_year = 112; // 2012
dt.dateTime.tm_mon = 6; // July
dt.dateTime.tm_mday = 31;
dt.dateTime.tm_hour = 13;
dt.dateTime.tm_min = 33;
dt.dateTime.tm_sec = 55;
dt.fSecs.value = 839;
dt.fSecs.offset = 5;
tmp_err_code += serialize.dateTimeData(&testStrm, dt);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("2012 Jul 31 13:33", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </dateTimeTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_BIN_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <binaryTest>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.binaryData(&testStrm, SOME_BINARY_DATA, 10);
}
else
{
// schema-less mode
tmp_err_code += serialize.stringData(&testStrm, SOME_BINARY_DATA_BASE64);
}
tmp_err_code += serialize.endElement(&testStrm); // </binaryTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_ENUM_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <enumTest>
tmp_err_code += serialize.stringData(&testStrm, ENUM_DATA_4);
tmp_err_code += serialize.endElement(&testStrm); // </enumTest>
tmp_err_code += serialize.endElement(&testStrm); // </extendedTypeTest>
tmp_err_code += serialize.endElement(&testStrm); // </MultipleXSDsTest>
tmp_err_code += serialize.endDocument(&testStrm);
if(tmp_err_code != ERR_OK)
printError(tmp_err_code, &testStrm, outfile);
// VI: Free the memory allocated by the EXI stream object
tmp_err_code = serialize.closeEXIStream(&testStrm);
fclose(outfile);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
}
}
else
{
printfHelp();
return 1;
}
return 0;
}
/**
* @brief Writes an attribute (libxml2 compatibility function)
* @param[in] writer An EXIStream
* @param[in] name Attribute name
* @param[in] value Attribute value
* @return 0 if success, -1 if error
*/
static int xmlTextWriterWriteAttribute(xmlTextWriterPtr writer, char*name, char *value) {
String uri = {NULL,0};
String localName = {NULL,0};
QName qname = {&uri, &localName, NULL };
String chVal;
int ret = 0;
int type = 0;
PRINT ("AT %s=%s\n", name, value);
if (strcmp(name,"xsi:type") == 0)
{
type = VALUE_TYPE_QNAME_CLASS;
}
else if (g_schemaPtr && strstr(name, "xmlns"))
return 0;
name = strdup(name);
char *pfx;
char *lname = strchr(name, ':');
if (lname) {
pfx = name;
*lname++ = 0;
pfx = getNamespaceByPrefix(pfx);
uri.str = pfx;
uri.length = strlen(pfx);
}
else {
//pfx = "";
/* XXX
uri.str = g_NsDefault;
uri.length = strlen(g_NsDefault);
*/
lname = name;
}
localName.str = lname;
localName.length = strlen(lname);
if (g_schemaPtr) {
if (!strcmp(lname, "xmlns")) {
strcpy (g_NsDefault, value);
/*
String ns = { value, strlen(value) };
errorCode err = serialize.namespaceDeclaration(writer, ns, localName, 0);
printf ("serialize.namespaceDeclaration(%s , %s)\n", value, lname);
*/
//XoAddNameSpace(lname, value);
}
else {
ret = ExiSerialize(writer, qname, value, TRUE, type);
}
}
else {
EXITypeClass valueType;
PRINT ("serialize.attribute ");
writeQName(qname);
PRINT ("\n");
ret += serialize.attribute(writer, qname, TRUE, &valueType);
if (ret) {
free(name);return -1;
}
// xsi:type
if (type == VALUE_TYPE_QNAME_CLASS) {
serializeXSITYPE(writer, value);
}
else {
ret += asciiToString((char *)value, &chVal, &writer->memList, FALSE);
PRINT ("serialize.stringData (%s)\n", value);
ret += serialize.stringData(writer, chVal);
}
}
free (name);
if (ret) return -1;
return 0;
}
END_TEST
START_TEST (test_noLearning02)
{
EXIStream testStrm;
Parser testParser;
String uri;
String ln;
QName qname= {&uri, &ln};
String chVal;
char buf[OUTPUT_BUFFER_SIZE];
errorCode tmp_err_code = EXIP_UNEXPECTED_ERROR;
BinaryBuffer buffer;
EXITypeClass valueType;
buffer.buf = buf;
buffer.bufContent = 0;
buffer.bufLen = OUTPUT_BUFFER_SIZE;
buffer.ioStrm.readWriteToStream = NULL;
buffer.ioStrm.stream = NULL;
// Serialization steps:
// I: First initialize the header of the stream
serialize.initHeader(&testStrm);
// II: Set any options in the header, if different from the defaults
testStrm.header.has_options = TRUE;
testStrm.header.opts.schemaIDMode = SCHEMA_ID_EMPTY;
// III: Define an external stream for the output if any
// IV: Initialize the stream
tmp_err_code = serialize.initStream(&testStrm, buffer, NULL);
fail_unless (tmp_err_code == EXIP_OK, "initStream returns an error code %d", tmp_err_code);
// V: Start building the stream step by step: header, document, element etc...
tmp_err_code = serialize.exiHeader(&testStrm);
fail_unless (tmp_err_code == EXIP_OK, "serialize.exiHeader returns an error code %d", tmp_err_code);
tmp_err_code = serialize.startDocument(&testStrm);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startDocument returns an error code %d", tmp_err_code);
getEmptyString(&uri);
tmp_err_code += asciiToString("root", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.startElement(&testStrm, qname, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("a", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.startElement(&testStrm, qname, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("bla", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code);
tmp_err_code += serialize.endElement(&testStrm);
tmp_err_code += asciiToString("b", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.startElement(&testStrm, qname, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("23", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code);
tmp_err_code += serialize.endElement(&testStrm);
tmp_err_code += asciiToString("a", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.startElement(&testStrm, qname, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("bla", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code);
tmp_err_code += serialize.endElement(&testStrm);
tmp_err_code += asciiToString("c", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.startElement(&testStrm, qname, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("b", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.startElement(&testStrm, qname, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("http://www.w3.org/2001/XMLSchema-instance", &uri, &testStrm.memList, FALSE);
tmp_err_code += asciiToString("type", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.attribute(&testStrm, qname, TRUE, &valueType);
fail_unless (tmp_err_code == EXIP_OK, "serialize.attribute returns an error code %d", tmp_err_code);
tmp_err_code += asciiToString("http://www.w3.org/2001/XMLSchema", &uri, &testStrm.memList, FALSE);
tmp_err_code += asciiToString("integer", &ln, &testStrm.memList, FALSE);
tmp_err_code += serialize.qnameData(&testStrm, qname);
fail_unless (tmp_err_code == EXIP_OK, "serialize.qnameData returns an error code %d", tmp_err_code);
tmp_err_code += serialize.intData(&testStrm, 66);
fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code);
tmp_err_code += serialize.endElement(&testStrm);
tmp_err_code += serialize.endElement(&testStrm);
tmp_err_code += serialize.endElement(&testStrm);
tmp_err_code += serialize.endDocument(&testStrm);
if(tmp_err_code != EXIP_OK)
fail_unless (tmp_err_code == EXIP_OK, "serialization ended with error code %d", tmp_err_code);
// V: Free the memory allocated by the EXI stream object
tmp_err_code = serialize.closeEXIStream(&testStrm);
fail_unless (tmp_err_code == EXIP_OK, "serialize.closeEXIStream ended with error code %d", tmp_err_code);
buffer.bufContent = OUTPUT_BUFFER_SIZE;
// Parsing steps:
// I: First, define an external stream for the input to the parser if any
// II: Second, initialize the parser object
tmp_err_code = initParser(&testParser, buffer, NULL);
fail_unless (tmp_err_code == EXIP_OK, "initParser returns an error code %d", tmp_err_code);
// III: Initialize the parsing data and hook the callback handlers to the parser object
// IV: Parse the header of the stream
tmp_err_code = parseHeader(&testParser, TRUE);
fail_unless (tmp_err_code == EXIP_OK, "parsing the header returns an error code %d", tmp_err_code);
tmp_err_code = setSchema(&testParser, NULL);
fail_unless (tmp_err_code == EXIP_OK, "setSchema() returns an error code %d", tmp_err_code);
// V: Parse the body of the EXI stream
while(tmp_err_code == EXIP_OK)
{
tmp_err_code = parseNext(&testParser);
}
// VI: Free the memory allocated by the parser object
destroyParser(&testParser);
fail_unless (tmp_err_code == EXIP_PARSING_COMPLETE, "Error during parsing of the EXI body %d", tmp_err_code);
}
