Ignore:
Timestamp:
12/27/07 16:11:27 (6 years ago)
Author:
xi
Message:

Fixed bugs and updated tests.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/tests/run-emitter.c

    r242 r265  
    1313#define MAX_EVENTS  1024 
    1414 
    15 int copy_event(yaml_event_t *event_to, yaml_event_t *event_from) 
     15int compare_events(const yaml_event_t *event, const yaml_event_t *model) 
    1616{ 
    17     switch (event_from->type) 
     17    yaml_char_t *event_anchor = NULL; 
     18    yaml_char_t *model_anchor = NULL; 
     19    yaml_char_t *event_tag = NULL; 
     20    yaml_char_t *model_tag = NULL; 
     21    yaml_char_t *event_value = NULL; 
     22    yaml_char_t *model_value = NULL; 
     23    size_t event_length = 0; 
     24    size_t model_length = 0; 
     25    int idx; 
     26 
     27    if (event->type != model->type) 
     28        return 0; 
     29 
     30    switch (event->type) 
    1831    { 
    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  
    2632        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); 
     33            if (!event->data.document_start.version_directive != 
     34                    !model->data.document_start.version_directive) 
     35                return 0; 
     36            if (event->data.document_start.version_directive) { 
     37                yaml_version_directive_t *event_version_directive = 
     38                    event->data.document_start.version_directive; 
     39                yaml_version_directive_t *model_version_directive = 
     40                    model->data.document_start.version_directive; 
     41                if (event_version_directive->major != 
     42                        model_version_directive->major || 
     43                        event_version_directive->minor != 
     44                        model_version_directive->minor) 
     45                    return 0; 
     46            } 
     47            if (event->data.document_start.tag_directives.length != 
     48                    model->data.document_start.tag_directives.length) 
     49                return 0; 
     50            for (idx = 0; idx < event->data.document_start.tag_directives.length; idx++) { 
     51                yaml_tag_directive_t *event_tag_directive = 
     52                    event->data.document_start.tag_directives.list + idx; 
     53                yaml_tag_directive_t *model_tag_directive = 
     54                    model->data.document_start.tag_directives.list + idx; 
     55                if (strcmp(event_tag_directive->handle, model_tag_directive->handle)) 
     56                    return 0; 
     57                if (strcmp(event_tag_directive->prefix, model_tag_directive->prefix)) 
     58                    return 0; 
     59            } 
     60            break; 
    3661 
    3762        case YAML_ALIAS_EVENT: 
    38             return yaml_alias_event_initialize(event_to, 
    39                     event_from->data.alias.anchor); 
     63            event_anchor = event->data.alias.anchor; 
     64            model_anchor = model->data.alias.anchor; 
     65            break; 
    4066 
    4167        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); 
     68            event_anchor = event->data.scalar.anchor; 
     69            model_anchor = model->data.scalar.anchor; 
     70            event_tag = event->data.scalar.tag; 
     71            model_tag = model->data.scalar.tag; 
     72            event_value = event->data.scalar.value; 
     73            model_value = model->data.scalar.value; 
     74            event_length = event->data.scalar.length; 
     75            model_length = model->data.scalar.length; 
     76            if (event->data.scalar.is_plain_implicit != 
     77                    model->data.scalar.is_plain_implicit) 
     78                return 0; 
     79            if (event->data.scalar.is_quoted_implicit != 
     80                    model->data.scalar.is_quoted_implicit) 
     81                return 0; 
     82            break; 
    5083 
    5184        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); 
     85            event_anchor = event->data.sequence_start.anchor; 
     86            model_anchor = model->data.sequence_start.anchor; 
     87            event_tag = event->data.sequence_start.tag; 
     88            model_tag = model->data.sequence_start.tag; 
     89            if (event->data.sequence_start.is_implicit != 
     90                    model->data.sequence_start.is_implicit) 
     91                return 0; 
     92            break; 
    6093 
    6194        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); 
     95            event_anchor = event->data.mapping_start.anchor; 
     96            model_anchor = model->data.mapping_start.anchor; 
     97            event_tag = event->data.mapping_start.tag; 
     98            model_tag = model->data.mapping_start.tag; 
     99            if (event->data.mapping_start.is_implicit != 
     100                    model->data.mapping_start.is_implicit) 
     101                return 0; 
     102            break; 
    70103 
    71104        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     } 
     105            break; 
     106    } 
     107 
     108    if (!event_anchor != !model_anchor) 
     109        return 0; 
     110    if (event_anchor && strcmp(event_anchor, model_anchor)) 
     111        return 0; 
     112 
     113    if (event_tag && !strcmp(event_tag, "!")) 
     114        event_tag = NULL; 
     115    if (model_tag && !strcmp(model_tag, "!")) 
     116        model_tag = NULL; 
     117    if (!event_tag != !model_tag) 
     118        return 0; 
     119    if (event_tag && strcmp(event_tag, model_tag)) 
     120        return 0; 
     121 
     122    if (event_length != model_length) 
     123        return 0; 
     124    if (event_length && memcmp(event_value, model_value, event_length)) 
     125        return 0; 
     126 
     127    return 1; 
    186128} 
    187129 
     
    214156main(int argc, char *argv[]) 
    215157{ 
    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]); 
     158    int idx; 
     159    int is_canonical = 0; 
     160    int is_unicode = 0; 
     161 
     162    idx = 1; 
     163    while (idx < argc) { 
     164        if (strcmp(argv[idx], "-c") == 0) { 
     165            is_canonical = 1; 
     166        } 
     167        else if (strcmp(argv[idx], "-u") == 0) { 
     168            is_unicode = 1; 
     169        } 
     170        else if (argv[idx][0] == '-') { 
     171            printf("Unknown option: '%s'\n", argv[idx]); 
    230172            return 0; 
    231173        } 
    232         if (argv[number][0] == '-') { 
    233             if (number < argc-1) { 
    234                 memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *)); 
     174        if (argv[idx][0] == '-') { 
     175            if (idx < argc-1) { 
     176                memmove(argv+idx, argv+idx+1, (argc-idx-1)*sizeof(char *)); 
    235177            } 
    236178            argc --; 
    237179        } 
    238180        else { 
    239             number ++; 
     181            idx ++; 
    240182        } 
    241183    } 
     
    246188    } 
    247189 
    248     for (number = 1; number < argc; number ++) 
     190    for (idx = 1; idx < argc; idx ++) 
    249191    { 
    250192        FILE *file; 
    251         yaml_parser_t parser; 
    252         yaml_emitter_t emitter; 
     193        yaml_parser_t *parser; 
     194        yaml_emitter_t *emitter; 
    253195        yaml_event_t event; 
    254196        unsigned char buffer[BUFFER_SIZE]; 
     
    256198        yaml_event_t events[MAX_EVENTS]; 
    257199        size_t event_number = 0; 
    258         int done = 0; 
    259200        int count = 0; 
    260         int error = 0; 
    261         int k; 
     201        int failed = 0; 
     202 
    262203        memset(buffer, 0, BUFFER_SIZE); 
    263204        memset(events, 0, MAX_EVENTS*sizeof(yaml_event_t)); 
    264205 
    265         printf("[%d] Parsing, emitting, and parsing again '%s': ", number, argv[number]); 
     206        printf("[%d] Parsing, emitting, and parsing again '%s': ", idx, argv[idx]); 
    266207        fflush(stdout); 
    267208 
    268         file = fopen(argv[number], "rb"); 
     209        file = fopen(argv[idx], "rb"); 
    269210        assert(file); 
    270211 
    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) 
     212        parser = yaml_parser_new(); 
     213        assert(parser); 
     214 
     215        yaml_parser_set_file_reader(parser, file); 
     216 
     217        emitter = yaml_emitter_new(); 
     218        assert(emitter); 
     219 
     220        if (is_canonical) { 
     221            yaml_emitter_set_canonical(emitter, 1); 
     222        } 
     223        if (is_unicode) { 
     224            yaml_emitter_set_unicode(emitter, 1); 
     225        } 
     226        yaml_emitter_set_string_writer(emitter, buffer, BUFFER_SIZE, &written); 
     227 
     228        while (1) 
    283229        { 
    284             if (!yaml_parser_parse(&parser, &event)) { 
    285                 error = 1; 
     230            if (!yaml_parser_parse_event(parser, &event)) 
     231                failed = 1; 
     232 
     233            if (!event.type) 
    286234                break; 
    287             } 
    288  
    289             done = (event.type == YAML_STREAM_END_EVENT); 
     235 
    290236            assert(event_number < MAX_EVENTS); 
    291             assert(copy_event(&(events[event_number++]), &event)); 
    292             assert(yaml_emitter_emit(&emitter, &event) ||  
    293                     (yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count))); 
     237            yaml_event_duplicate(&(events[event_number++]), &event); 
     238            assert(yaml_emitter_emit_event(emitter, &event) ||  
     239                    (yaml_emitter_flush(emitter) && 
     240                     print_output(argv[idx], buffer, written, count))); 
    294241            count ++; 
    295242        } 
    296243 
    297         yaml_parser_delete(&parser); 
    298         assert(!fclose(file)); 
    299         yaml_emitter_delete(&emitter); 
    300  
    301         if (!error) 
     244        yaml_parser_delete(parser); 
     245        fclose(file); 
     246        yaml_emitter_delete(emitter); 
     247 
     248        if (!failed) 
    302249        { 
    303             count = done = 0; 
    304             assert(yaml_parser_initialize(&parser)); 
    305             yaml_parser_set_input_string(&parser, buffer, written); 
    306  
    307             while (!done) 
     250            count = 0; 
     251            parser = yaml_parser_new(); 
     252            yaml_parser_set_string_reader(parser, buffer, written); 
     253 
     254            while (1) 
    308255            { 
    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); 
     256                assert(yaml_parser_parse_event(parser, &event) || 
     257                        print_output(argv[idx], buffer, written, count)); 
     258                if (!event.type) 
     259                    break; 
     260                assert(compare_events(events+count, &event) || 
     261                        print_output(argv[idx], buffer, written, count)); 
     262                yaml_event_destroy(&event); 
    313263                count ++; 
    314264            } 
    315             yaml_parser_delete(&parser); 
    316         } 
    317  
    318         for (k = 0; k < event_number; k ++) { 
    319             yaml_event_delete(events+k); 
     265            yaml_parser_delete(parser); 
     266        } 
     267 
     268        while(event_number) { 
     269            yaml_event_destroy(events+(--event_number)); 
    320270        } 
    321271 
    322272        printf("PASSED (length: %d)\n", written); 
    323         print_output(argv[number], buffer, written, -1); 
     273        print_output(argv[idx], buffer, written, -1); 
    324274    } 
    325275 
Note: See TracChangeset for help on using the changeset viewer.