Subversion Repositories PlanixRsrch.SVN

Rev

Rev 194 | Blame | Compare with Previous | Last modification | View Log | RSS feed

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

#include <mutests.h>

#include "mgen.h"



static char *
gen_test_file(char *str)
{
        FILE *f;
        char *filename;
        filename = tmpnam(NULL);
        f=fopen(filename,"wt");
        (void)fprintf(f,str);
        (void)fclose(f);
        return filename;
}



int test_mgen_read_rule_set1(char *bnf, char *prg, char * start, int wrc)
{
        char * filename;
        MGEN_FILE * mf;
        struct mgen_rule_set * rules;
        int rc;

        filename = gen_test_file(bnf);
        mf = mgen_open(filename,"");
        rules = mgen_read_rule_set(mf);

        mu_assert(rules!=NULL,"create rules");
        (void) remove(filename);

        filename = gen_test_file(prg);
        mf = mgen_open(filename,"");
        rc = mgen_parse(mf,rules, start);
        mu_assert(rc == wrc, "mgen_parse  bnf: %s, prg: %s",bnf,prg);

        (void) remove (filename);
        return 1;
}

int test_mgen_read_rule_set()
{
        int rc;
        rc = test_mgen_read_rule_set1(
                "<Program> ::= a b c",
                "abc",
                "Program",
                1);
        rc |= test_mgen_read_rule_set1(
                "<Program> ::= a b c",
                "abx",
                "Program",
                0);
        rc |= test_mgen_read_rule_set1(
"<Program> ::= <Word> a b c\n\
<Word> ::= <Letter> <Wordrest>\n\
<Wordrest> ::= <Letter> | \n\
<Letter> ::= x | y | z"
,

"xyabc",
                "Program",
                1);
        rc |= test_mgen_read_rule_set1(
"<Programm1>       ::= a b c\n"
"<Programm>       ::= <Wort> Z u m s e l\n"
"<Buchstabe>      ::= <Kleinbuchstabe> | <Grossbuchstabe>\n"
"<Wort>           ::= <Buchstabe> <Wortrest> <Delimiter>\n"
"<Wortrest>       ::= <Buchstabe> <Wortrest> |\n"
"<Kleinbuchstabe> ::= a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z\n"
"<Grossbuchstabe> ::= A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z\n"
"<Delimiter>      ::= _ <Delimiterrest>\n"
"<Delimiterrest>  ::= <Delimiter> |\n",
                "Z____Zumsel",
                "Programm",
                1);

        return rc;
}

int test_mgen_ring_seek1(char *str,int bufsize,int blocksize)
{
        char * filename;
        MGEN_FILE * mf;
        int i,c,rc;

        filename = gen_test_file(str);

        mf = mgen_open(filename,"");
        mu_assert(mf!=NULL, "seek: can't open file %s",filename);

        mgen_ring_set_block_size(&mf->ring,(size_t)blocksize);
        mgen_ring_set_buffer_size(&mf->ring,(size_t)bufsize);

        for(i=0; i<(int)strlen(str); i++){
                c = mgen_getc(mf);
                mu_assert( c == str[i], "seek: test 1");
        }

        for(i=0; i<(int)strlen(str); i++){
                rc = mgen_ring_seek(&mf->ring,(size_t)i);
                if ( (int)strlen(str)-i > bufsize  )
                        mu_assert(!rc,"seek: test 44");
                else{
                        mu_assert(rc,"seek: test 45");
                        c = mgen_getc(mf);
                        mu_assert (c == str[i], "seek: test 77");
                }
        }

        (void)remove(filename);
        return 1;
}

int test_mgen_ring_seek()
{
        int rc=0;
        rc |= test_mgen_ring_seek1("012345678",5,3);
        rc |= test_mgen_ring_seek1("0123456789123",100,3);
        rc |= test_mgen_ring_seek1("xxaass0123456789123",5,1);
        rc |= test_mgen_ring_seek1("12345678",8,2);
        rc |= test_mgen_ring_seek1("12345678",8,8);
        rc |= test_mgen_ring_seek1("12345678",9,8);
        return rc;
}



int test_mgen_getc()
{
        MGEN_FILE * mf;
        char * str;
        char *filename;
        int i,rc;
        int maxbuf,diff,blocksize;

        str = "Hello World"; /* 11 characters */
        diff = 3;
        blocksize = 2;
        maxbuf  = (int)strlen(str)-diff;

        filename = gen_test_file(str);

        mf = mgen_open(filename,"");
        mu_assert(mf!=NULL, "can't open file %s",filename);

        mgen_ring_set_block_size(&mf->ring,(size_t)blocksize);
        mgen_ring_set_buffer_size(&mf->ring,(size_t)maxbuf);

        for (i=0; (size_t)i<strlen(str); i++){
                int c;
                c = mgen_getc(mf);
                mu_assert(c == str[i],"test 1");
                mu_assert((size_t)i+1 == mf->ring.abspos,"test 2");
        }

/*      mu_assert(mf->ring.pos == (size_t)maxbuf % (size_t)diff-1, "test 3");*/

        /* unget characters into the whole buffer */
        for (i=0; i<maxbuf; i++){
                rc = mgen_ungetc('0'+i,mf);
                mu_assert(rc == '0'+i,"test 4");
        }
       
        /* unget one more character should result in EOF */
        rc = mgen_ungetc('x',mf);
        mu_assert( rc == EOF, "test 5");
       
        for (i=0; i<maxbuf; i++){
                rc = mgen_getc(mf);
                mu_assert(rc == '0'+maxbuf-1-i, "test 6");
        }

        rc = mgen_getc(mf);
        mu_assert(rc == EOF,"test 7");

        (void)fclose(mf->infile);
        (void)remove(filename);

        return 1;
}      

int main()
{
        mutests tf = {
                test_mgen_getc,
                test_mgen_ring_seek,
                test_mgen_read_rule_set,
                NULL
        };
        return mutests_run(tf);
}