Ignore:
Timestamp:
07/21/06 09:50:32 (8 years ago)
Author:
xi
Message:

Refactor internal and external API.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libyaml/trunk/tests/test-reader.c

    r200 r208  
    11#include <yaml.h> 
     2 
     3YAML_DECLARE(int) 
     4yaml_parser_update_buffer(yaml_parser_t *parser, size_t length); 
    25 
    36#include <stdlib.h> 
     
    102105    {"bom (utf-8)", "\xef\xbb\xbfHi is \xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82!", 13}, 
    103106    {"bom (utf-16-le)", "\xff\xfeH\x00i\x00 \x00i\x00s\x00 \x00\x1f\x04@\x04""8\x04""2\x04""5\x04""B\x04!", 13}, 
    104     {"bom (utf-16-be)", "\xfe\xff\x00H\x00i\x00 \x00i\x00s\x00 \x04\x1f\x04@\x04""8\x04""2\x04""5\x04""B!", 13} 
     107    {"bom (utf-16-be)", "\xfe\xff\x00H\x00i\x00 \x00i\x00s\x00 \x04\x1f\x04@\x04""8\x04""2\x04""5\x04""B!", 13}, 
     108    {NULL, NULL, 0} 
    105109}; 
    106110 
     
    109113int check_utf8_sequences(void) 
    110114{ 
    111     yaml_parser_t *parser; 
     115    yaml_parser_t parser; 
    112116    int failed = 0; 
    113117    int k; 
     
    122126        while(1) { 
    123127            while (*end != '|' && *end != '!') end++; 
    124             parser = yaml_parser_new(); 
    125             assert(parser); 
    126             yaml_parser_set_input_string(parser, (unsigned char *)start, end-start); 
    127             result = yaml_parser_update_buffer(parser, end-start); 
     128            yaml_parser_initialize(&parser); 
     129            yaml_parser_set_input_string(&parser, (unsigned char *)start, end-start); 
     130            result = yaml_parser_update_buffer(&parser, end-start); 
    128131            if (result != check) { 
    129132                printf("\t\t- "); 
     
    133136                printf("\t\t+ "); 
    134137            } 
    135             if (!parser->error) { 
     138            if (!parser.error) { 
    136139                printf("(no error)\n"); 
    137140            } 
    138             else if (parser->error == YAML_READER_ERROR) { 
    139                 if (parser->problem_value != -1) { 
     141            else if (parser.error == YAML_READER_ERROR) { 
     142                if (parser.problem_value != -1) { 
    140143                    printf("(reader error: %s: #%X at %d)\n", 
    141                             parser->problem, parser->problem_value, parser->problem_offset); 
     144                            parser.problem, parser.problem_value, parser.problem_offset); 
    142145                } 
    143146                else { 
    144147                    printf("(reader error: %s at %d)\n", 
    145                             parser->problem, parser->problem_offset); 
     148                            parser.problem, parser.problem_offset); 
    146149                } 
    147150            } 
    148151            if (*end == '!') break; 
    149152            start = ++end; 
    150             yaml_parser_delete(parser); 
     153            yaml_parser_delete(&parser); 
    151154        }; 
    152155        printf("\n"); 
     
    158161int check_boms(void) 
    159162{ 
    160     yaml_parser_t *parser; 
     163    yaml_parser_t parser; 
    161164    int failed = 0; 
    162165    int k; 
     
    170173        while (*end != '!') end++; 
    171174        printf("\t%s: ", title); 
    172         parser = yaml_parser_new(); 
    173         assert(parser); 
    174         yaml_parser_set_input_string(parser, (unsigned char *)start, end-start); 
    175         result = yaml_parser_update_buffer(parser, end-start); 
     175        yaml_parser_initialize(&parser); 
     176        yaml_parser_set_input_string(&parser, (unsigned char *)start, end-start); 
     177        result = yaml_parser_update_buffer(&parser, end-start); 
    176178        if (!result) { 
    177             printf("- (reader error: %s at %d)\n", parser->problem, parser->problem_offset); 
     179            printf("- (reader error: %s at %d)\n", parser.problem, parser.problem_offset); 
    178180            failed++; 
    179181        } 
    180182        else { 
    181             if (parser->unread != check) { 
    182                 printf("- (length=%d while expected length=%d)\n", parser->unread, check); 
     183            if (parser.unread != check) { 
     184                printf("- (length=%d while expected length=%d)\n", parser.unread, check); 
    183185                failed++; 
    184186            } 
    185             else if (memcmp(parser->buffer, bom_original, check) != 0) { 
    186                 printf("- (value '%s' does not equal to the original value '%s')\n", parser->buffer, bom_original); 
     187            else if (memcmp(parser.buffer.start, bom_original, check) != 0) { 
     188                printf("- (value '%s' does not equal to the original value '%s')\n", parser.buffer.start, bom_original); 
    187189                failed++; 
    188190            } 
     
    191193            } 
    192194        } 
    193         yaml_parser_delete(parser); 
     195        yaml_parser_delete(&parser); 
    194196    } 
    195197    printf("checking boms: %d fail(s)\n", failed); 
     
    201203int check_long_utf8(void) 
    202204{ 
    203     yaml_parser_t *parser; 
     205    yaml_parser_t parser; 
    204206    int k = 0; 
    205207    int j; 
     
    222224        } 
    223225    } 
    224     parser = yaml_parser_new(); 
    225     assert(parser); 
    226     yaml_parser_set_input_string(parser, buffer, 3+LONG*2); 
     226    yaml_parser_initialize(&parser); 
     227    yaml_parser_set_input_string(&parser, buffer, 3+LONG*2); 
    227228    for (k = 0; k < LONG; k++) { 
    228         if (!parser->unread) { 
    229             if (!yaml_parser_update_buffer(parser, 1)) { 
    230                 printf("\treader error: %s at %d\n", parser->problem, parser->problem_offset); 
     229        if (!parser.unread) { 
     230            if (!yaml_parser_update_buffer(&parser, 1)) { 
     231                printf("\treader error: %s at %d\n", parser.problem, parser.problem_offset); 
    231232                failed = 1; 
    232233                break; 
    233234            } 
    234235        } 
    235         if (!parser->unread) { 
     236        if (!parser.unread) { 
    236237            printf("\tnot enough characters at %d\n", k); 
    237238            failed = 1; 
     
    246247            ch1 = '\xaf'; 
    247248        } 
    248         if (parser->pointer[0] != ch0 || parser->pointer[1] != ch1) { 
     249        if (parser.buffer.pointer[0] != ch0 || parser.buffer.pointer[1] != ch1) { 
    249250            printf("\tincorrect UTF-8 sequence: %X %X instead of %X %X\n", 
    250                     (int)parser->pointer[0], (int)parser->pointer[1], 
     251                    (int)parser.buffer.pointer[0], (int)parser.buffer.pointer[1], 
    251252                    (int)ch0, (int)ch1); 
    252253            failed = 1; 
    253254            break; 
    254255        } 
    255         parser->pointer += 2; 
    256         parser->unread -= 1; 
     256        parser.buffer.pointer += 2; 
     257        parser.unread -= 1; 
    257258    } 
    258259    if (!failed) { 
    259         if (!yaml_parser_update_buffer(parser, 1)) { 
    260             printf("\treader error: %s at %d\n", parser->problem, parser->problem_offset); 
    261             failed = 1; 
    262         } 
    263         else if (parser->pointer[0] != '\0') { 
    264             printf("\texpected NUL, found %X (eof=%d, unread=%d)\n", (int)parser->pointer[0], parser->eof, parser->unread); 
    265             failed = 1; 
    266         } 
    267     } 
    268     yaml_parser_delete(parser); 
     260        if (!yaml_parser_update_buffer(&parser, 1)) { 
     261            printf("\treader error: %s at %d\n", parser.problem, parser.problem_offset); 
     262            failed = 1; 
     263        } 
     264        else if (parser.buffer.pointer[0] != '\0') { 
     265            printf("\texpected NUL, found %X (eof=%d, unread=%d)\n", (int)parser.buffer.pointer[0], parser.eof, parser.unread); 
     266            failed = 1; 
     267        } 
     268    } 
     269    yaml_parser_delete(&parser); 
    269270    free(buffer); 
    270271    printf("checking a long utf8 sequence: %d fail(s)\n", failed); 
     
    274275int check_long_utf16(void) 
    275276{ 
    276     yaml_parser_t *parser; 
     277    yaml_parser_t parser; 
    277278    int k = 0; 
    278279    int j; 
     
    294295        } 
    295296    } 
    296     parser = yaml_parser_new(); 
    297     assert(parser); 
    298     yaml_parser_set_input_string(parser, buffer, 2+LONG*2); 
     297    yaml_parser_initialize(&parser); 
     298    yaml_parser_set_input_string(&parser, buffer, 2+LONG*2); 
    299299    for (k = 0; k < LONG; k++) { 
    300         if (!parser->unread) { 
    301             if (!yaml_parser_update_buffer(parser, 1)) { 
    302                 printf("\treader error: %s at %d\n", parser->problem, parser->problem_offset); 
     300        if (!parser.unread) { 
     301            if (!yaml_parser_update_buffer(&parser, 1)) { 
     302                printf("\treader error: %s at %d\n", parser.problem, parser.problem_offset); 
    303303                failed = 1; 
    304304                break; 
    305305            } 
    306306        } 
    307         if (!parser->unread) { 
     307        if (!parser.unread) { 
    308308            printf("\tnot enough characters at %d\n", k); 
    309309            failed = 1; 
     
    318318            ch1 = '\xaf'; 
    319319        } 
    320         if (parser->pointer[0] != ch0 || parser->pointer[1] != ch1) { 
     320        if (parser.buffer.pointer[0] != ch0 || parser.buffer.pointer[1] != ch1) { 
    321321            printf("\tincorrect UTF-8 sequence: %X %X instead of %X %X\n", 
    322                     (int)parser->pointer[0], (int)parser->pointer[1], 
     322                    (int)parser.buffer.pointer[0], (int)parser.buffer.pointer[1], 
    323323                    (int)ch0, (int)ch1); 
    324324            failed = 1; 
    325325            break; 
    326326        } 
    327         parser->pointer += 2; 
    328         parser->unread -= 1; 
     327        parser.buffer.pointer += 2; 
     328        parser.unread -= 1; 
    329329    } 
    330330    if (!failed) { 
    331         if (!yaml_parser_update_buffer(parser, 1)) { 
    332             printf("\treader error: %s at %d\n", parser->problem, parser->problem_offset); 
    333             failed = 1; 
    334         } 
    335         else if (parser->pointer[0] != '\0') { 
    336             printf("\texpected NUL, found %X (eof=%d, unread=%d)\n", (int)parser->pointer[0], parser->eof, parser->unread); 
    337             failed = 1; 
    338         } 
    339     } 
    340     yaml_parser_delete(parser); 
     331        if (!yaml_parser_update_buffer(&parser, 1)) { 
     332            printf("\treader error: %s at %d\n", parser.problem, parser.problem_offset); 
     333            failed = 1; 
     334        } 
     335        else if (parser.buffer.pointer[0] != '\0') { 
     336            printf("\texpected NUL, found %X (eof=%d, unread=%d)\n", (int)parser.buffer.pointer[0], parser.eof, parser.unread); 
     337            failed = 1; 
     338        } 
     339    } 
     340    yaml_parser_delete(&parser); 
    341341    free(buffer); 
    342342    printf("checking a long utf16 sequence: %d fail(s)\n", failed); 
Note: See TracChangeset for help on using the changeset viewer.