[libyaml.git] / tests / run-dumper.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_DOCUMENTS  16

int copy_document(yaml_document_t *document_to, yaml_document_t *document_from)
{
    yaml_node_t *node;
    yaml_node_item_t *item;
    yaml_node_pair_t *pair;

    if (!yaml_document_initialize(document_to, document_from->version_directive,
                document_from->tag_directives.start,
                document_from->tag_directives.end,
                document_from->start_implicit, document_from->end_implicit))
        return 0;

    for (node = document_from->nodes.start;
            node < document_from->nodes.top; node ++) {
        switch (node->type) {
            case YAML_SCALAR_NODE:
                if (!yaml_document_add_scalar(document_to, node->tag,
                            node->data.scalar.value, node->data.scalar.length,
                            node->data.scalar.style)) goto error;
                break;
            case YAML_SEQUENCE_NODE:
                if (!yaml_document_add_sequence(document_to, node->tag,
                            node->data.sequence.style)) goto error;
                break;
            case YAML_MAPPING_NODE:
                if (!yaml_document_add_mapping(document_to, node->tag,
                            node->data.mapping.style)) goto error;
                break;
            default:
                assert(0);
                break;
        }
    }

    for (node = document_from->nodes.start;
            node < document_from->nodes.top; node ++) {
        switch (node->type) {
            case YAML_SEQUENCE_NODE:
                for (item = node->data.sequence.items.start;
                        item < node->data.sequence.items.top; item ++) {
                    if (!yaml_document_append_sequence_item(document_to,
                                node - document_from->nodes.start + 1,
                                *item)) goto error;
                }
                break;
            case YAML_MAPPING_NODE:
                for (pair = node->data.mapping.pairs.start;
                        pair < node->data.mapping.pairs.top; pair ++) {
                    if (!yaml_document_append_mapping_pair(document_to,
                                node - document_from->nodes.start + 1,
                                pair->key, pair->value)) goto error;
                }
                break;
            default:
                break;
        }
    }
    return 1;

error:
    yaml_document_delete(document_to);
    return 0;
}

int compare_nodes(yaml_document_t *document1, int index1,
        yaml_document_t *document2, int index2, int level)
{
    int k;
    yaml_node_t *node1;
    yaml_node_t *node2;
    if (level++ > 1000) return 0;
    node1 = yaml_document_get_node(document1, index1);
    node2 = yaml_document_get_node(document2, index2);

    assert(node1);
    assert(node2);

    if (node1->type != node2->type)
        return 0;

    if (strcmp((char *)node1->tag, (char *)node2->tag) != 0) return 0;

    switch (node1->type) {
        case YAML_SCALAR_NODE:
            if (node1->data.scalar.length != node2->data.scalar.length)
                return 0;
            if (strncmp((char *)node1->data.scalar.value, (char *)node2->data.scalar.value,
                        node1->data.scalar.length) != 0) return 0;
            break;
        case YAML_SEQUENCE_NODE:
            if ((node1->data.sequence.items.top - node1->data.sequence.items.start) !=
                    (node2->data.sequence.items.top - node2->data.sequence.items.start))
                return 0;
            for (k = 0; k < (node1->data.sequence.items.top - node1->data.sequence.items.start); k ++) {
                if (!compare_nodes(document1, node1->data.sequence.items.start[k],
                            document2, node2->data.sequence.items.start[k], level)) return 0;
            }
            break;
        case YAML_MAPPING_NODE:
            if ((node1->data.mapping.pairs.top - node1->data.mapping.pairs.start) !=
                    (node2->data.mapping.pairs.top - node2->data.mapping.pairs.start))
                return 0;
            for (k = 0; k < (node1->data.mapping.pairs.top - node1->data.mapping.pairs.start); k ++) {
                if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].key,
                            document2, node2->data.mapping.pairs.start[k].key, level)) return 0;
                if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].value,
                            document2, node2->data.mapping.pairs.start[k].value, level)) return 0;
            }
            break;
        default:
            assert(0);
            break;
    }
    return 1;
}

int compare_documents(yaml_document_t *document1, yaml_document_t *document2)
{
    int k;

    if ((document1->version_directive && !document2->version_directive)
            || (!document1->version_directive && document2->version_directive)
            || (document1->version_directive && document2->version_directive
                && (document1->version_directive->major != document2->version_directive->major
                    || document1->version_directive->minor != document2->version_directive->minor)))
        return 0;

    if ((document1->tag_directives.end - document1->tag_directives.start) !=
            (document2->tag_directives.end - document2->tag_directives.start))
        return 0;
    for (k = 0; k < (document1->tag_directives.end - document1->tag_directives.start); k ++) {
        if ((strcmp((char *)document1->tag_directives.start[k].handle,
                        (char *)document2->tag_directives.start[k].handle) != 0)
                || (strcmp((char *)document1->tag_directives.start[k].prefix,
                    (char *)document2->tag_directives.start[k].prefix) != 0))
            return 0;
    }

    if ((document1->nodes.top - document1->nodes.start) !=
            (document2->nodes.top - document2->nodes.start))
        return 0;

    if (document1->nodes.top != document1->nodes.start) {
        if (!compare_nodes(document1, 1, document2, 1, 0))
            return 0;
    }

    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 document #%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_document_t document;
        unsigned char buffer[BUFFER_SIZE+1];
        size_t written = 0;
        yaml_document_t documents[MAX_DOCUMENTS];
        size_t document_number = 0;
        int done = 0;
        int count = 0;
        int error = 0;
        int k;
        memset(buffer, 0, BUFFER_SIZE+1);
        memset(documents, 0, MAX_DOCUMENTS*sizeof(yaml_document_t));

        printf("[%d] Loading, dumping, and loading 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);
        yaml_emitter_open(&emitter);

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

            done = (!yaml_document_get_root_node(&document));
            if (!done) {
                assert(document_number < MAX_DOCUMENTS);
                assert(copy_document(&(documents[document_number++]), &document));
                assert(yaml_emitter_dump(&emitter, &document) || 
                        (yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count)));
                count ++;
            }
            else {
                yaml_document_delete(&document);
            }
        }

        yaml_parser_delete(&parser);
        assert(!fclose(file));
        yaml_emitter_close(&emitter);
        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_load(&parser, &document) || print_output(argv[number], buffer, written, count));
                done = (!yaml_document_get_root_node(&document));
                if (!done) {
                    assert(compare_documents(documents+count, &document) || print_output(argv[number], buffer, written, count));
                    count ++;
                }
                yaml_document_delete(&document);
            }
            yaml_parser_delete(&parser);
        }

        for (k = 0; k < document_number; k ++) {
            yaml_document_delete(documents+k);
        }

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

    return 0;
}
Commit	Line	Data
e27a3c88 KS	1	#include <yaml.h>
	2
	3	#include <stdlib.h>
	4	#include <stdio.h>
e27a3c88 KS	5	#include <string.h>
e27a3c88 KS	6
01224901 KS	7	#ifdef NDEBUG
	8	#undef NDEBUG
	9	#endif
	10	#include <assert.h>
	11
e27a3c88 KS	12	#define BUFFER_SIZE 65536
	13	#define MAX_DOCUMENTS 16
	14
	15	int copy_document(yaml_document_t document_to, yaml_document_t document_from)
	16	{
	17	yaml_node_t *node;
	18	yaml_node_item_t *item;
	19	yaml_node_pair_t *pair;
	20
	21	if (!yaml_document_initialize(document_to, document_from->version_directive,
	22	document_from->tag_directives.start,
	23	document_from->tag_directives.end,
	24	document_from->start_implicit, document_from->end_implicit))
	25	return 0;
	26
	27	for (node = document_from->nodes.start;
	28	node < document_from->nodes.top; node ++) {
	29	switch (node->type) {
	30	case YAML_SCALAR_NODE:
	31	if (!yaml_document_add_scalar(document_to, node->tag,
	32	node->data.scalar.value, node->data.scalar.length,
	33	node->data.scalar.style)) goto error;
	34	break;
	35	case YAML_SEQUENCE_NODE:
	36	if (!yaml_document_add_sequence(document_to, node->tag,
	37	node->data.sequence.style)) goto error;
	38	break;
	39	case YAML_MAPPING_NODE:
	40	if (!yaml_document_add_mapping(document_to, node->tag,
	41	node->data.mapping.style)) goto error;
	42	break;
	43	default:
	44	assert(0);
	45	break;
	46	}
	47	}
	48
	49	for (node = document_from->nodes.start;
	50	node < document_from->nodes.top; node ++) {
	51	switch (node->type) {
	52	case YAML_SEQUENCE_NODE:
	53	for (item = node->data.sequence.items.start;
	54	item < node->data.sequence.items.top; item ++) {
	55	if (!yaml_document_append_sequence_item(document_to,
	56	node - document_from->nodes.start + 1,
	57	*item)) goto error;
	58	}
	59	break;
	60	case YAML_MAPPING_NODE:
	61	for (pair = node->data.mapping.pairs.start;
	62	pair < node->data.mapping.pairs.top; pair ++) {
	63	if (!yaml_document_append_mapping_pair(document_to,
	64	node - document_from->nodes.start + 1,
	65	pair->key, pair->value)) goto error;
	66	}
	67	break;
	68	default:
	69	break;
	70	}
	71	}
	72	return 1;
	73
	74	error:
	75	yaml_document_delete(document_to);
76	return 0;
77	}
78
79	int compare_nodes(yaml_document_t *document1, int index1,
3b570fc9	80	yaml_document_t *document2, int index2, int level)
e27a3c88	81	{
e27a3c88	82	int k;
1560fc82 TM	83	yaml_node_t *node1;
	84	yaml_node_t *node2;
	85	if (level++ > 1000) return 0;
	86	node1 = yaml_document_get_node(document1, index1);
	87	node2 = yaml_document_get_node(document2, index2);
e27a3c88 KS	88
	89	assert(node1);
	90	assert(node2);
	91
	92	if (node1->type != node2->type)
	93	return 0;
	94
	95	if (strcmp((char )node1->tag, (char )node2->tag) != 0) return 0;
	96
	97	switch (node1->type) {
	98	case YAML_SCALAR_NODE:
	99	if (node1->data.scalar.length != node2->data.scalar.length)
	100	return 0;
	101	if (strncmp((char )node1->data.scalar.value, (char )node2->data.scalar.value,
	102	node1->data.scalar.length) != 0) return 0;
	103	break;
	104	case YAML_SEQUENCE_NODE:
	105	if ((node1->data.sequence.items.top - node1->data.sequence.items.start) !=
	106	(node2->data.sequence.items.top - node2->data.sequence.items.start))
	107	return 0;
	108	for (k = 0; k < (node1->data.sequence.items.top - node1->data.sequence.items.start); k ++) {
	109	if (!compare_nodes(document1, node1->data.sequence.items.start[k],
3b570fc9	110	document2, node2->data.sequence.items.start[k], level)) return 0;
e27a3c88 KS	111	}
	112	break;
	113	case YAML_MAPPING_NODE:
	114	if ((node1->data.mapping.pairs.top - node1->data.mapping.pairs.start) !=
	115	(node2->data.mapping.pairs.top - node2->data.mapping.pairs.start))
	116	return 0;
	117	for (k = 0; k < (node1->data.mapping.pairs.top - node1->data.mapping.pairs.start); k ++) {
	118	if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].key,
3b570fc9	119	document2, node2->data.mapping.pairs.start[k].key, level)) return 0;
e27a3c88	120	if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].value,
3b570fc9	121	document2, node2->data.mapping.pairs.start[k].value, level)) return 0;
e27a3c88 KS	122	}
e27a3c88 KS	123	break;
01224901 KS	124	default:
	125	assert(0);
	126	break;
e27a3c88 KS	127	}
	128	return 1;
	129	}
	130
	131	int compare_documents(yaml_document_t document1, yaml_document_t document2)
	132	{
	133	int k;
	134
	135	if ((document1->version_directive && !document2->version_directive)
	136	\|\| (!document1->version_directive && document2->version_directive)
	137	\|\| (document1->version_directive && document2->version_directive
	138	&& (document1->version_directive->major != document2->version_directive->major
	139	\|\| document1->version_directive->minor != document2->version_directive->minor)))
	140	return 0;
	141
	142	if ((document1->tag_directives.end - document1->tag_directives.start) !=
	143	(document2->tag_directives.end - document2->tag_directives.start))
	144	return 0;
	145	for (k = 0; k < (document1->tag_directives.end - document1->tag_directives.start); k ++) {
	146	if ((strcmp((char *)document1->tag_directives.start[k].handle,
	147	(char *)document2->tag_directives.start[k].handle) != 0)
	148	\|\| (strcmp((char *)document1->tag_directives.start[k].prefix,
	149	(char *)document2->tag_directives.start[k].prefix) != 0))
	150	return 0;
	151	}
	152
	153	if ((document1->nodes.top - document1->nodes.start) !=
	154	(document2->nodes.top - document2->nodes.start))
	155	return 0;
	156
	157	if (document1->nodes.top != document1->nodes.start) {
3b570fc9	158	if (!compare_nodes(document1, 1, document2, 1, 0))
e27a3c88 KS	159	return 0;
	160	}
	161
	162	return 1;
	163	}
	164
	165	int print_output(char name, unsigned char buffer, size_t size, int count)
	166	{
	167	FILE *file;
	168	char data[BUFFER_SIZE];
	169	size_t data_size = 1;
	170	size_t total_size = 0;
	171	if (count >= 0) {
	172	printf("FAILED (at the document #%d)\nSOURCE:\n", count+1);
	173	}
	174	file = fopen(name, "rb");
	175	assert(file);
	176	while (data_size > 0) {
	177	data_size = fread(data, 1, BUFFER_SIZE, file);
	178	assert(!ferror(file));
	179	if (!data_size) break;
	180	assert(fwrite(data, 1, data_size, stdout) == data_size);
	181	total_size += data_size;
	182	if (feof(file)) break;
	183	}
	184	fclose(file);
fc2dd942 RU	185	printf("#### (length: %ld)\n", (long)total_size);
fc2dd942 RU	186	printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
e27a3c88 KS	187	return 0;
	188	}
	189
	190	int
	191	main(int argc, char *argv[])
	192	{
	193	int number;
	194	int canonical = 0;
	195	int unicode = 0;
	196
	197	number = 1;
	198	while (number < argc) {
	199	if (strcmp(argv[number], "-c") == 0) {
	200	canonical = 1;
	201	}
	202	else if (strcmp(argv[number], "-u") == 0) {
	203	unicode = 1;
	204	}
	205	else if (argv[number][0] == '-') {
	206	printf("Unknown option: '%s'\n", argv[number]);
	207	return 0;
	208	}
	209	if (argv[number][0] == '-') {
	210	if (number < argc-1) {
	211	memmove(argv+number, argv+number+1, (argc-number-1)sizeof(char ));
	212	}
	213	argc --;
	214	}
	215	else {
	216	number ++;
	217	}
	218	}
	219
	220	if (argc < 2) {
	221	printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
	222	return 0;
	223	}
	224
	225	for (number = 1; number < argc; number ++)
	226	{
	227	FILE *file;
	228	yaml_parser_t parser;
	229	yaml_emitter_t emitter;
	230
	231	yaml_document_t document;
3b570fc9	232	unsigned char buffer[BUFFER_SIZE+1];
e27a3c88 KS	233	size_t written = 0;
	234	yaml_document_t documents[MAX_DOCUMENTS];
	235	size_t document_number = 0;
	236	int done = 0;
	237	int count = 0;
	238	int error = 0;
	239	int k;
3b570fc9	240	memset(buffer, 0, BUFFER_SIZE+1);
e27a3c88 KS	241	memset(documents, 0, MAX_DOCUMENTS*sizeof(yaml_document_t));
	242
	243	printf("[%d] Loading, dumping, and loading again '%s': ", number, argv[number]);
	244	fflush(stdout);
	245
	246	file = fopen(argv[number], "rb");
	247	assert(file);
	248
	249	assert(yaml_parser_initialize(&parser));
	250	yaml_parser_set_input_file(&parser, file);
	251	assert(yaml_emitter_initialize(&emitter));
	252	if (canonical) {
	253	yaml_emitter_set_canonical(&emitter, 1);
	254	}
	255	if (unicode) {
	256	yaml_emitter_set_unicode(&emitter, 1);
	257	}
	258	yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);
	259	yaml_emitter_open(&emitter);
	260
	261	while (!done)
	262	{
	263	if (!yaml_parser_load(&parser, &document)) {
	264	error = 1;
	265	break;
	266	}
	267
	268	done = (!yaml_document_get_root_node(&document));
	269	if (!done) {
	270	assert(document_number < MAX_DOCUMENTS);
	271	assert(copy_document(&(documents[document_number++]), &document));
	272	assert(yaml_emitter_dump(&emitter, &document) \|\|
	273	(yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count)));
	274	count ++;
	275	}
	276	else {
	277	yaml_document_delete(&document);
	278	}
	279	}
	280
	281	yaml_parser_delete(&parser);
	282	assert(!fclose(file));
	283	yaml_emitter_close(&emitter);
	284	yaml_emitter_delete(&emitter);
	285
	286	if (!error)
	287	{
	288	count = done = 0;
	289	assert(yaml_parser_initialize(&parser));
	290	yaml_parser_set_input_string(&parser, buffer, written);
	291
	292	while (!done)
	293	{
	294	assert(yaml_parser_load(&parser, &document) \|\| print_output(argv[number], buffer, written, count));
	295	done = (!yaml_document_get_root_node(&document));
	296	if (!done) {
	297	assert(compare_documents(documents+count, &document) \|\| print_output(argv[number], buffer, written, count));
	298	count ++;
	299	}
	300	yaml_document_delete(&document);
	301	}
	302	yaml_parser_delete(&parser);
	303	}
	304
305	for (k = 0; k < document_number; k ++) {
306	yaml_document_delete(documents+k);
307	}
308
fc2dd942	309	printf("PASSED (length: %ld)\n", (long)written);
e27a3c88 KS	310	print_output(argv[number], buffer, written, -1);
	311	}
	312
	313	return 0;
	314	}