[libyaml.git] / tests / run-emitter.c

#include <yaml.h>

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

#ifdef NDEBUG
#undef NDEBUG
#endif
#include <assert.h>

#define BUFFER_SIZE 65536
#define MAX_EVENTS  1024

int copy_event(yaml_event_t *event_to, yaml_event_t *event_from)
{
    switch (event_from->type)
    {
        case YAML_STREAM_START_EVENT:
            return yaml_stream_start_event_initialize(event_to,
                    event_from->data.stream_start.encoding);

        case YAML_STREAM_END_EVENT:
            return yaml_stream_end_event_initialize(event_to);

        case YAML_DOCUMENT_START_EVENT:
            return yaml_document_start_event_initialize(event_to,
                    event_from->data.document_start.version_directive,
                    event_from->data.document_start.tag_directives.start,
                    event_from->data.document_start.tag_directives.end,
                    event_from->data.document_start.implicit);

        case YAML_DOCUMENT_END_EVENT:
            return yaml_document_end_event_initialize(event_to,
                    event_from->data.document_end.implicit);

        case YAML_ALIAS_EVENT:
            return yaml_alias_event_initialize(event_to,
                    event_from->data.alias.anchor);

        case YAML_SCALAR_EVENT:
            return yaml_scalar_event_initialize(event_to,
                    event_from->data.scalar.anchor,
                    event_from->data.scalar.tag,
                    event_from->data.scalar.value,
                    event_from->data.scalar.length,
                    event_from->data.scalar.plain_implicit,
                    event_from->data.scalar.quoted_implicit,
                    event_from->data.scalar.style);

        case YAML_SEQUENCE_START_EVENT:
            return yaml_sequence_start_event_initialize(event_to,
                    event_from->data.sequence_start.anchor,
                    event_from->data.sequence_start.tag,
                    event_from->data.sequence_start.implicit,
                    event_from->data.sequence_start.style);

        case YAML_SEQUENCE_END_EVENT:
            return yaml_sequence_end_event_initialize(event_to);

        case YAML_MAPPING_START_EVENT:
            return yaml_mapping_start_event_initialize(event_to,
                    event_from->data.mapping_start.anchor,
                    event_from->data.mapping_start.tag,
                    event_from->data.mapping_start.implicit,
                    event_from->data.mapping_start.style);

        case YAML_MAPPING_END_EVENT:
            return yaml_mapping_end_event_initialize(event_to);

        default:
            assert(1);
    }

    return 0;
}

int compare_events(yaml_event_t *event1, yaml_event_t *event2)
{
    int k;

    if (event1->type != event2->type)
        return 0;

    switch (event1->type)
    {
        case YAML_STREAM_START_EVENT:
            return 1;
            /* return (event1->data.stream_start.encoding ==
                    event2->data.stream_start.encoding); */

        case YAML_DOCUMENT_START_EVENT:
            if ((event1->data.document_start.version_directive && !event2->data.document_start.version_directive)
                    || (!event1->data.document_start.version_directive && event2->data.document_start.version_directive)
                    || (event1->data.document_start.version_directive && event2->data.document_start.version_directive
                        && (event1->data.document_start.version_directive->major != event2->data.document_start.version_directive->major
                            || event1->data.document_start.version_directive->minor != event2->data.document_start.version_directive->minor)))
                return 0;
            if ((event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start) !=
                    (event2->data.document_start.tag_directives.end - event2->data.document_start.tag_directives.start))
                return 0;
            for (k = 0; k < (event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start); k ++) {
                if ((strcmp((char *)event1->data.document_start.tag_directives.start[k].handle,
                                (char *)event2->data.document_start.tag_directives.start[k].handle) != 0)
                        || (strcmp((char *)event1->data.document_start.tag_directives.start[k].prefix,
                            (char *)event2->data.document_start.tag_directives.start[k].prefix) != 0))
                    return 0;
            }
            /* if (event1->data.document_start.implicit != event2->data.document_start.implicit)
                return 0; */
            return 1;

        case YAML_DOCUMENT_END_EVENT:
            return 1;
            /* return (event1->data.document_end.implicit ==
                    event2->data.document_end.implicit); */

        case YAML_ALIAS_EVENT:
            return (strcmp((char *)event1->data.alias.anchor,
                        (char *)event2->data.alias.anchor) == 0);

        case YAML_SCALAR_EVENT:
            if ((event1->data.scalar.anchor && !event2->data.scalar.anchor)
                    || (!event1->data.scalar.anchor && event2->data.scalar.anchor)
                    || (event1->data.scalar.anchor && event2->data.scalar.anchor
                        && strcmp((char *)event1->data.scalar.anchor,
                            (char *)event2->data.scalar.anchor) != 0))
                return 0;
            if ((event1->data.scalar.tag && !event2->data.scalar.tag
                        && strcmp((char *)event1->data.scalar.tag, "!") != 0)
                    || (!event1->data.scalar.tag && event2->data.scalar.tag
                        && strcmp((char *)event2->data.scalar.tag, "!") != 0)
                    || (event1->data.scalar.tag && event2->data.scalar.tag
                        && strcmp((char *)event1->data.scalar.tag,
                            (char *)event2->data.scalar.tag) != 0))
                return 0;
            if ((event1->data.scalar.length != event2->data.scalar.length)
                    || memcmp(event1->data.scalar.value, event2->data.scalar.value,
                        event1->data.scalar.length) != 0)
                return 0;
            if ((event1->data.scalar.plain_implicit != event2->data.scalar.plain_implicit)
                    || (event2->data.scalar.quoted_implicit != event2->data.scalar.quoted_implicit)
                    /* || (event2->data.scalar.style != event2->data.scalar.style) */)
                return 0;
            return 1;

        case YAML_SEQUENCE_START_EVENT:
            if ((event1->data.sequence_start.anchor && !event2->data.sequence_start.anchor)
                    || (!event1->data.sequence_start.anchor && event2->data.sequence_start.anchor)
                    || (event1->data.sequence_start.anchor && event2->data.sequence_start.anchor
                        && strcmp((char *)event1->data.sequence_start.anchor,
                            (char *)event2->data.sequence_start.anchor) != 0))
                return 0;
            if ((event1->data.sequence_start.tag && !event2->data.sequence_start.tag)
                    || (!event1->data.sequence_start.tag && event2->data.sequence_start.tag)
                    || (event1->data.sequence_start.tag && event2->data.sequence_start.tag
                        && strcmp((char *)event1->data.sequence_start.tag,
                            (char *)event2->data.sequence_start.tag) != 0))
                return 0;
            if ((event1->data.sequence_start.implicit != event2->data.sequence_start.implicit)
                    /* || (event2->data.sequence_start.style != event2->data.sequence_start.style) */)
                return 0;
            return 1;

        case YAML_MAPPING_START_EVENT:
            if ((event1->data.mapping_start.anchor && !event2->data.mapping_start.anchor)
                    || (!event1->data.mapping_start.anchor && event2->data.mapping_start.anchor)
                    || (event1->data.mapping_start.anchor && event2->data.mapping_start.anchor
                        && strcmp((char *)event1->data.mapping_start.anchor,
                            (char *)event2->data.mapping_start.anchor) != 0))
                return 0;
            if ((event1->data.mapping_start.tag && !event2->data.mapping_start.tag)
                    || (!event1->data.mapping_start.tag && event2->data.mapping_start.tag)
                    || (event1->data.mapping_start.tag && event2->data.mapping_start.tag
                        && strcmp((char *)event1->data.mapping_start.tag,
                            (char *)event2->data.mapping_start.tag) != 0))
                return 0;
            if ((event1->data.mapping_start.implicit != event2->data.mapping_start.implicit)
                    /* || (event2->data.mapping_start.style != event2->data.mapping_start.style) */)
                return 0;
            return 1;

        default:
            return 1;
    }
}

int print_output(char *name, unsigned char *buffer, size_t size, int count)
{
    FILE *file;
    char data[BUFFER_SIZE];
    size_t data_size = 1;
    size_t total_size = 0;
    if (count >= 0) {
        printf("FAILED (at the event #%d)\nSOURCE:\n", count+1);
    }
    file = fopen(name, "rb");
    assert(file);
    while (data_size > 0) {
        data_size = fread(data, 1, BUFFER_SIZE, file);
        assert(!ferror(file));
        if (!data_size) break;
        assert(fwrite(data, 1, data_size, stdout) == data_size);
        total_size += data_size;
        if (feof(file)) break;
    }
    fclose(file);
    printf("#### (length: %ld)\n", (long)total_size);
    printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
    return 0;
}

int
main(int argc, char *argv[])
{
    int number;
    int canonical = 0;
    int unicode = 0;

    number = 1;
    while (number < argc) {
        if (strcmp(argv[number], "-c") == 0) {
            canonical = 1;
        }
        else if (strcmp(argv[number], "-u") == 0) {
            unicode = 1;
        }
        else if (argv[number][0] == '-') {
            printf("Unknown option: '%s'\n", argv[number]);
            return 0;
        }
        if (argv[number][0] == '-') {
            if (number < argc-1) {
                memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *));
            }
            argc --;
        }
        else {
            number ++;
        }
    }

    if (argc < 2) {
        printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
        return 0;
    }

    for (number = 1; number < argc; number ++)
    {
        FILE *file;
        yaml_parser_t parser;
        yaml_emitter_t emitter;
        yaml_event_t event;
        unsigned char buffer[BUFFER_SIZE+1];
        size_t written = 0;
        yaml_event_t events[MAX_EVENTS];
        size_t event_number = 0;
        int done = 0;
        int count = 0;
        int error = 0;
        int k;
        memset(buffer, 0, BUFFER_SIZE+1);
        memset(events, 0, MAX_EVENTS*sizeof(yaml_event_t));

        printf("[%d] Parsing, emitting, and parsing again '%s': ", number, argv[number]);
        fflush(stdout);

        file = fopen(argv[number], "rb");
        assert(file);

        assert(yaml_parser_initialize(&parser));
        yaml_parser_set_input_file(&parser, file);
        assert(yaml_emitter_initialize(&emitter));
        if (canonical) {
            yaml_emitter_set_canonical(&emitter, 1);
        }
        if (unicode) {
            yaml_emitter_set_unicode(&emitter, 1);
        }
        yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);

        while (!done)
        {
            if (!yaml_parser_parse(&parser, &event)) {
                error = 1;
                break;
            }

            done = (event.type == YAML_STREAM_END_EVENT);
            assert(event_number < MAX_EVENTS);
            assert(copy_event(&(events[event_number++]), &event));
            assert(yaml_emitter_emit(&emitter, &event) || 
                    print_output(argv[number], buffer, written, count));
            count ++;
        }

        yaml_parser_delete(&parser);
        assert(!fclose(file));
        yaml_emitter_delete(&emitter);

        if (!error)
        {
            count = done = 0;
            assert(yaml_parser_initialize(&parser));
            yaml_parser_set_input_string(&parser, buffer, written);

            while (!done)
            {
                assert(yaml_parser_parse(&parser, &event) || print_output(argv[number], buffer, written, count));
                done = (event.type == YAML_STREAM_END_EVENT);
                assert(compare_events(events+count, &event) || print_output(argv[number], buffer, written, count));
                yaml_event_delete(&event);
                count ++;
            }
            yaml_parser_delete(&parser);
        }

        for (k = 0; k < event_number; k ++) {
            yaml_event_delete(events+k);
        }

        printf("PASSED (length: %ld)\n", (long)written);
        print_output(argv[number], buffer, written, -1);
    }

    return 0;
}
Commit	Line	Data
b3043c48 KS	1	#include <yaml.h>
	2
	3	#include <stdlib.h>
	4	#include <stdio.h>
b3043c48 KS	5	#include <string.h>
b3043c48 KS	6
01224901 KS	7	#ifdef NDEBUG
	8	#undef NDEBUG
	9	#endif
	10	#include <assert.h>
	11
b3043c48 KS	12	#define BUFFER_SIZE 65536
	13	#define MAX_EVENTS 1024
	14
	15	int copy_event(yaml_event_t event_to, yaml_event_t event_from)
	16	{
	17	switch (event_from->type)
	18	{
	19	case YAML_STREAM_START_EVENT:
	20	return yaml_stream_start_event_initialize(event_to,
	21	event_from->data.stream_start.encoding);
	22
	23	case YAML_STREAM_END_EVENT:
	24	return yaml_stream_end_event_initialize(event_to);
	25
	26	case YAML_DOCUMENT_START_EVENT:
	27	return yaml_document_start_event_initialize(event_to,
	28	event_from->data.document_start.version_directive,
	29	event_from->data.document_start.tag_directives.start,
	30	event_from->data.document_start.tag_directives.end,
	31	event_from->data.document_start.implicit);
	32
	33	case YAML_DOCUMENT_END_EVENT:
	34	return yaml_document_end_event_initialize(event_to,
	35	event_from->data.document_end.implicit);
	36
	37	case YAML_ALIAS_EVENT:
	38	return yaml_alias_event_initialize(event_to,
	39	event_from->data.alias.anchor);
	40
	41	case YAML_SCALAR_EVENT:
	42	return yaml_scalar_event_initialize(event_to,
	43	event_from->data.scalar.anchor,
	44	event_from->data.scalar.tag,
	45	event_from->data.scalar.value,
	46	event_from->data.scalar.length,
	47	event_from->data.scalar.plain_implicit,
	48	event_from->data.scalar.quoted_implicit,
	49	event_from->data.scalar.style);
	50
	51	case YAML_SEQUENCE_START_EVENT:
	52	return yaml_sequence_start_event_initialize(event_to,
	53	event_from->data.sequence_start.anchor,
	54	event_from->data.sequence_start.tag,
	55	event_from->data.sequence_start.implicit,
	56	event_from->data.sequence_start.style);
	57
	58	case YAML_SEQUENCE_END_EVENT:
	59	return yaml_sequence_end_event_initialize(event_to);
	60
	61	case YAML_MAPPING_START_EVENT:
	62	return yaml_mapping_start_event_initialize(event_to,
	63	event_from->data.mapping_start.anchor,
	64	event_from->data.mapping_start.tag,
	65	event_from->data.mapping_start.implicit,
	66	event_from->data.mapping_start.style);
	67
	68	case YAML_MAPPING_END_EVENT:
	69	return yaml_mapping_end_event_initialize(event_to);
	70
	71	default:
	72	assert(1);
	73	}
	74
	75	return 0;
76	}
77
78	int compare_events(yaml_event_t event1, yaml_event_t event2)
79	{
80	int k;
81
82	if (event1->type != event2->type)
83	return 0;
84
85	switch (event1->type)
86	{
87	case YAML_STREAM_START_EVENT:
88	return 1;
89	/* return (event1->data.stream_start.encoding ==
90	event2->data.stream_start.encoding); */
91
92	case YAML_DOCUMENT_START_EVENT:
93	if ((event1->data.document_start.version_directive && !event2->data.document_start.version_directive)
94	\|\| (!event1->data.document_start.version_directive && event2->data.document_start.version_directive)
95	\|\| (event1->data.document_start.version_directive && event2->data.document_start.version_directive
96	&& (event1->data.document_start.version_directive->major != event2->data.document_start.version_directive->major
97	\|\| event1->data.document_start.version_directive->minor != event2->data.document_start.version_directive->minor)))
98	return 0;
99	if ((event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start) !=
100	(event2->data.document_start.tag_directives.end - event2->data.document_start.tag_directives.start))
101	return 0;
102	for (k = 0; k < (event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start); k ++) {
103	if ((strcmp((char *)event1->data.document_start.tag_directives.start[k].handle,
104	(char *)event2->data.document_start.tag_directives.start[k].handle) != 0)
105	\|\| (strcmp((char *)event1->data.document_start.tag_directives.start[k].prefix,
106	(char *)event2->data.document_start.tag_directives.start[k].prefix) != 0))
107	return 0;
108	}
109	/* if (event1->data.document_start.implicit != event2->data.document_start.implicit)
110	return 0; */
111	return 1;
112
113	case YAML_DOCUMENT_END_EVENT:
114	return 1;
115	/* return (event1->data.document_end.implicit ==
116	event2->data.document_end.implicit); */
117
118	case YAML_ALIAS_EVENT:
119	return (strcmp((char *)event1->data.alias.anchor,
120	(char *)event2->data.alias.anchor) == 0);
121
122	case YAML_SCALAR_EVENT:
123	if ((event1->data.scalar.anchor && !event2->data.scalar.anchor)
124	\|\| (!event1->data.scalar.anchor && event2->data.scalar.anchor)
125	\|\| (event1->data.scalar.anchor && event2->data.scalar.anchor
126	&& strcmp((char *)event1->data.scalar.anchor,
127	(char *)event2->data.scalar.anchor) != 0))
128	return 0;
129	if ((event1->data.scalar.tag && !event2->data.scalar.tag
130	&& strcmp((char *)event1->data.scalar.tag, "!") != 0)
131	\|\| (!event1->data.scalar.tag && event2->data.scalar.tag
132	&& strcmp((char *)event2->data.scalar.tag, "!") != 0)
133	\|\| (event1->data.scalar.tag && event2->data.scalar.tag
134	&& strcmp((char *)event1->data.scalar.tag,
135	(char *)event2->data.scalar.tag) != 0))
136	return 0;
137	if ((event1->data.scalar.length != event2->data.scalar.length)
138	\|\| memcmp(event1->data.scalar.value, event2->data.scalar.value,
139	event1->data.scalar.length) != 0)
140	return 0;
141	if ((event1->data.scalar.plain_implicit != event2->data.scalar.plain_implicit)
142	\|\| (event2->data.scalar.quoted_implicit != event2->data.scalar.quoted_implicit)
143	/* \|\| (event2->data.scalar.style != event2->data.scalar.style) */)
144	return 0;
145	return 1;
146
147	case YAML_SEQUENCE_START_EVENT:
148	if ((event1->data.sequence_start.anchor && !event2->data.sequence_start.anchor)
149	\|\| (!event1->data.sequence_start.anchor && event2->data.sequence_start.anchor)
150	\|\| (event1->data.sequence_start.anchor && event2->data.sequence_start.anchor
151	&& strcmp((char *)event1->data.sequence_start.anchor,
152	(char *)event2->data.sequence_start.anchor) != 0))
153	return 0;
154	if ((event1->data.sequence_start.tag && !event2->data.sequence_start.tag)
155	\|\| (!event1->data.sequence_start.tag && event2->data.sequence_start.tag)
156	\|\| (event1->data.sequence_start.tag && event2->data.sequence_start.tag
157	&& strcmp((char *)event1->data.sequence_start.tag,
158	(char *)event2->data.sequence_start.tag) != 0))
159	return 0;
160	if ((event1->data.sequence_start.implicit != event2->data.sequence_start.implicit)
161	/* \|\| (event2->data.sequence_start.style != event2->data.sequence_start.style) */)
162	return 0;
163	return 1;
164
165	case YAML_MAPPING_START_EVENT:
166	if ((event1->data.mapping_start.anchor && !event2->data.mapping_start.anchor)
167	\|\| (!event1->data.mapping_start.anchor && event2->data.mapping_start.anchor)
168	\|\| (event1->data.mapping_start.anchor && event2->data.mapping_start.anchor
169	&& strcmp((char *)event1->data.mapping_start.anchor,
170	(char *)event2->data.mapping_start.anchor) != 0))
171	return 0;
172	if ((event1->data.mapping_start.tag && !event2->data.mapping_start.tag)
173	\|\| (!event1->data.mapping_start.tag && event2->data.mapping_start.tag)
174	\|\| (event1->data.mapping_start.tag && event2->data.mapping_start.tag
175	&& strcmp((char *)event1->data.mapping_start.tag,
176	(char *)event2->data.mapping_start.tag) != 0))
177	return 0;
178	if ((event1->data.mapping_start.implicit != event2->data.mapping_start.implicit)
179	/* \|\| (event2->data.mapping_start.style != event2->data.mapping_start.style) */)
180	return 0;
181	return 1;
182
183	default:
184	return 1;
185	}
186	}
187
188	int print_output(char name, unsigned char buffer, size_t size, int count)
189	{
190	FILE *file;
191	char data[BUFFER_SIZE];
192	size_t data_size = 1;
193	size_t total_size = 0;
194	if (count >= 0) {
195	printf("FAILED (at the event #%d)\nSOURCE:\n", count+1);
196	}
197	file = fopen(name, "rb");
198	assert(file);
199	while (data_size > 0) {
200	data_size = fread(data, 1, BUFFER_SIZE, file);
201	assert(!ferror(file));
202	if (!data_size) break;
203	assert(fwrite(data, 1, data_size, stdout) == data_size);
204	total_size += data_size;
205	if (feof(file)) break;
206	}
207	fclose(file);
fc2dd942 RU	208	printf("#### (length: %ld)\n", (long)total_size);
fc2dd942 RU	209	printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
b3043c48 KS	210	return 0;
	211	}
	212
	213	int
	214	main(int argc, char *argv[])
	215	{
	216	int number;
	217	int canonical = 0;
	218	int unicode = 0;
	219
	220	number = 1;
	221	while (number < argc) {
	222	if (strcmp(argv[number], "-c") == 0) {
	223	canonical = 1;
	224	}
	225	else if (strcmp(argv[number], "-u") == 0) {
	226	unicode = 1;
	227	}
	228	else if (argv[number][0] == '-') {
	229	printf("Unknown option: '%s'\n", argv[number]);
	230	return 0;
	231	}
	232	if (argv[number][0] == '-') {
	233	if (number < argc-1) {
	234	memmove(argv+number, argv+number+1, (argc-number-1)sizeof(char ));
	235	}
	236	argc --;
	237	}
	238	else {
	239	number ++;
	240	}
	241	}
	242
	243	if (argc < 2) {
	244	printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
	245	return 0;
	246	}
	247
	248	for (number = 1; number < argc; number ++)
	249	{
	250	FILE *file;
	251	yaml_parser_t parser;
	252	yaml_emitter_t emitter;
	253	yaml_event_t event;
3b570fc9	254	unsigned char buffer[BUFFER_SIZE+1];
b3043c48 KS	255	size_t written = 0;
	256	yaml_event_t events[MAX_EVENTS];
	257	size_t event_number = 0;
	258	int done = 0;
	259	int count = 0;
	260	int error = 0;
	261	int k;
3b570fc9	262	memset(buffer, 0, BUFFER_SIZE+1);
e27a3c88	263	memset(events, 0, MAX_EVENTS*sizeof(yaml_event_t));
b3043c48 KS	264
	265	printf("[%d] Parsing, emitting, and parsing again '%s': ", number, argv[number]);
	266	fflush(stdout);
	267
	268	file = fopen(argv[number], "rb");
	269	assert(file);
	270
	271	assert(yaml_parser_initialize(&parser));
	272	yaml_parser_set_input_file(&parser, file);
	273	assert(yaml_emitter_initialize(&emitter));
	274	if (canonical) {
	275	yaml_emitter_set_canonical(&emitter, 1);
	276	}
	277	if (unicode) {
	278	yaml_emitter_set_unicode(&emitter, 1);
	279	}
	280	yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);
	281
	282	while (!done)
	283	{
	284	if (!yaml_parser_parse(&parser, &event)) {
	285	error = 1;
	286	break;
	287	}
	288
	289	done = (event.type == YAML_STREAM_END_EVENT);
	290	assert(event_number < MAX_EVENTS);
	291	assert(copy_event(&(events[event_number++]), &event));
	292	assert(yaml_emitter_emit(&emitter, &event) \|\|
45cf8b54	293	print_output(argv[number], buffer, written, count));
b3043c48 KS	294	count ++;
	295	}
	296
	297	yaml_parser_delete(&parser);
	298	assert(!fclose(file));
	299	yaml_emitter_delete(&emitter);
	300
	301	if (!error)
	302	{
	303	count = done = 0;
	304	assert(yaml_parser_initialize(&parser));
	305	yaml_parser_set_input_string(&parser, buffer, written);
	306
	307	while (!done)
	308	{
	309	assert(yaml_parser_parse(&parser, &event) \|\| print_output(argv[number], buffer, written, count));
	310	done = (event.type == YAML_STREAM_END_EVENT);
	311	assert(compare_events(events+count, &event) \|\| print_output(argv[number], buffer, written, count));
	312	yaml_event_delete(&event);
	313	count ++;
	314	}
	315	yaml_parser_delete(&parser);
	316	}
	317
	318	for (k = 0; k < event_number; k ++) {
	319	yaml_event_delete(events+k);
	320	}
	321
fc2dd942	322	printf("PASSED (length: %ld)\n", (long)written);
b3043c48 KS	323	print_output(argv[number], buffer, written, -1);
	324	}
	325
	326	return 0;
	327	}