test_ERAV.cpp

Go to the documentation of this file.

// test_ERAV.cpp (C) 2010 adolfo@di-mare.com

/** \file  test_ERAV.cpp
    \brief Test -> ERAV -> erav2xml() -> xml2erav().

    THIS IS PUBLIC DOMAIN SOFTWARE.
    - Use at you own risk
    - yes: it´s free.

    \author Adolfo Di Mare <adolfo@di-mare.com>
    \date   2010.
*/

#include "ERAV.h"

#include <fstream>
#include <iomanip>    // setw()
#include <iostream>

const char* ERAV::token::name(int tk) {
    // centered string when tk is ASCII
    static char ch[] = { '?',' ',' ',' ', 0 };
    switch (tk) {
        case 0:      return "ZERO ";
        case LTQ:    return "LTQ ";
        case QGT:    return "QGT ";
        case LTS:    return "LTS ";
        case SGT:    return "SGT ";
        case ID:     return "ID  ";
        case STRING: return "STRING";
        default:     *ch=tk; return ch;
    }
}

// These are the 3 variables that yylex() needs to keep its context.
struct yylex_state {
    const char *cursor;
    const char *text;
    int         leng;
    int         line;
};

// token output in 1 line.
void lexeme_line( int token, const yylex_state& yy ) {
    std::cout << "token(" << std::setw(6) << ERAV::token::name(token) << ") ";
    std::cout << " len("  << std::setw(2) << yy.leng << ") ";
    std::cout << " #ln( "  << std::setw(3) << yy.line << " )  lexeme == ";
    const char *y=yy.text; int len15 = (yy.leng>15 ? 15 : yy.leng);
    for (int i=0; i<len15; ++i,++y) { std::cout << (*y); }
    if ( yy.leng!=len15 ) { std::cout << " ....<"<< yy.leng << ">.... "; }
    std::cout << std::endl;
}

// Store into std::cin all tokens in file
int test_yylex( const char *file ) {
    std::fstream cin( file );
    std::string buf;
    while ( !cin.fail() ) {
        char ch;
        cin.get(ch);
        if (!cin.fail()) { buf += ch; }
    }
    char *tmp = new char[buf.length()+1];
    buf.copy( tmp, buf.length(),0 );
    tmp[buf.length()] = 0;
    if (false) { std::cout << tmp << std::endl; }
    int token;
    yylex_state yy;  yy.cursor = tmp; yy.line=1;
    do {
        token = ERAV::yylex( &yy.cursor, &yy.text, &yy.leng, &yy.line );
        lexeme_line( token , yy );
    } while (token != 0);
    return 0;
}

// Create tuple <id,rel,sub,t,attrib,val>.
// See http://www.di-mare.com/adolfo/cursos/2009-1/ERAV.jpg
ERAV::tuple make_tuple(
    int id, int rel , int sub, char t, int attrib, std::string val
) {
    ERAV::tuple T;
    T.ID_ENT   = id;
    T.REL.ID   = rel;
    T.REL.SUB  = sub;
    T.REL.TYPE = tolower(t);
    T.ATTRIB   = attrib;
    T.VAL.BLOB = val;
    return T;
}

// Load a complete ERAV list<> with it´s words and strings
void megaload(
    std::list<ERAV::tuple>& L ,
    ERAV::WORD&             W ,
    ERAV::WORD&             S
) {
    erav_clear(L,W,S);

    #define mktuple(id,rel,sub,t,a,v) L.push_back( make_tuple(id,rel,sub,t,a,v) )

    //       ID_ENT   REL_ID REL_SUB  T    ATTRIB      VAL
    mktuple( 1110111 , 0000 , 0000 , 'e' , 0001111 , ""         );
    mktuple( 1110111 , 0000 , 0000 , 's' , 2220000 , "7700002"  );
    mktuple( 1110111 , 0000 , 0000 , 'i' , 0001234 , "2"        );
    mktuple( 1110111 , 0000 , 0000 , 'a' , 1110111 , "1110123"  );
    mktuple( 2220222 , 0000 , 0000 , 'e' , 0001111 , ""         );
    mktuple( 2220222 , 0000 , 0000 , 's' , 2220000 , "7700001"  );
    mktuple( 1110111 , 0101 , 0000 , 'e' , 2220021 , ""         );
    mktuple( 1110111 , 0101 , 0000 , 's' , 5000002 , "7700021"  );
    mktuple( 1110111 , 0101 , 0000 , 'i' , 2220011 , "88887753" );
    mktuple( 1110111 , 0101 , 0000 , 's' , 5000005 , "7700022"  );
    mktuple( 1110111 , 0201 , 0101 , 'e' , 2220022 , ""         );
    mktuple( 1110111 , 0201 , 0101 , 'd' , 5000003 , "20080923" );
    mktuple( 1110111 , 0201 , 0101 , 'f' , 5000004 , "250.55"   );
    mktuple( 1110111 , 0202 , 0101 , 'e' , 2220022 , ""         );
    mktuple( 1110111 , 0202 , 0101 , 'd' , 5000003 , "20081025" );
    mktuple( 1110111 , 0202 , 0101 , 'f' , 2220024 , "386.12"   );
    mktuple( 1110111 , 0202 , 0101 , 'f' , 5000004 , "256.55"   );
    mktuple( 1110111 , 0203 , 0101 , 'e' , 2220022 , ""         );
    mktuple( 1110111 , 0203 , 0101 , 'd' , 5000003 , "20081112" );
    mktuple( 1110111 , 0203 , 0101 , 'f' , 5000004 , "260.33"   );
    mktuple( 1110111 , 0102 , 0000 , 'e' , 2220021 , ""         );
    mktuple( 1110111 , 0102 , 0000 , 's' , 5000002 , "7700024"  );
    mktuple( 1110111 , 0102 , 0000 , 'i' , 2220011 , "77538888" );
    mktuple( 1110111 , 0102 , 0000 , 's' , 5000005 , "7700025"  );
    mktuple( 1110111 , 0205 , 0102 , 'e' , 2220022 , ""         );
    mktuple( 1110111 , 0205 , 0102 , 'd' , 5000003 , "20090615" );
    mktuple( 1110111 , 0205 , 0102 , 'f' , 5000004 , "325.12"   );
    mktuple( 1110111 , 0301 , 0000 , 'e' , 2220023 , ""         );
    mktuple( 1110111 , 0301 , 0000 , 'd' , 5000003 , "20051231" );
    mktuple( 1110111 , 0302 , 0000 , 's' , 2220023 , "7700023"  );
    mktuple( 2220222 , 0101 , 0000 , 'e' , 2220023 , ""         );
    mktuple( 2220222 , 0101 , 0000 , 's' , 5000002 , "7700024"  );
    mktuple( 2220222 , 0101 , 0000 , 'i' , 2220011 , "77538888" );
    mktuple( 2220222 , 0101 , 0000 , 's' , 5000005 , "7700025"  );
    mktuple( 2220222 , 0201 , 0000 , 'e' , 2220024 , ""         );
    mktuple( 2220222 , 0201 , 0000 , 'd' , 5000003 , "20051302" );

    #undef mktuple

    //        ID_WORD   LANG   DESCR
    W.update( 0001111 , "es", "automotor"        );
    W.update( 0001234 , "es", "cantidad puertas" );
    W.update( 0001234 , "en", "number doors"     );
    W.update( 1110111 , "es", "color"            );
    W.update( 1110123 , "es", "azul"             );
    W.update( 2220000 , "es", "marca"            );
    W.update( 2220000 , "en", "brand"            );
    W.update( 2220011 , "es", "teléfono"         );
    W.update( 2220011 , "en", "phone"            );
    W.update( 2220021 , "es", "mecánico"         );
    W.update( 2220022 , "es", "revisión"         );
    W.update( 2220023 , "es", "dueño"            );
    W.update( 2220024 , "es", "aceite"           );
    W.update( 5000001 , "es", "alógeno"          );
    W.update( 5000002 , "es", "nombre"           );
    W.update( 5000003 , "es", "fecha"            );
    W.update( 5000004 , "es", "monto"            );
    W.update( 5000005 , "es", "dirección"        );
    W.update( 6660011 , "es", "foto"             );
    W.update( 2220021 , "en", "mechanic"         );
    W.update( 2220022 , "en", "revision"         );
    W.update( 2220023 , "en", "owner"            );
    W.update( 2220024 , "en", "oil"              );
    W.update( 5000001 , "en", "halogen"          );
    W.update( 5000002 , "en", "name"             );
    W.update( 5000003 , "en", "date"             );
    W.update( 5000004 , "en", "amount"           );
    W.update( 5000005 , "en", "address"          );
    W.update( 6660011 , "en", "photo"            );

    //       ID_STRIN   LANG   DESCR
    S.update( 7700001 , "**", "hyundai"                       );
    S.update( 7700002 , "**", "toyota"                        );
    S.update( 7700021 , "**", "Juan Mecánico"                 );
    S.update( 7700022 , "es", "200 Sur del Palo de Guayaba"   );
    S.update( 7700022 , "en", "200 South of the Guayaba tree" );
    S.update( 7700023 , "**", "Pepe Lerdeando"                );
    S.update( 7700024 , "**", "Pedro Mecánico"                );
    S.update( 7700025 , "es", "3 kms al este del Guayabero"   );
    S.update( 7700025 , "en", "2 miles east from Guayabero"   );
}

extern void dump_tuples( const std::list<ERAV::tuple>& L );

void dump_tuples( const std::list<ERAV::tuple>& L ) {
    using namespace std;
    if ( L.empty() ) { std::cout << " [ L.empty() ]\n"; }
    std::list<ERAV::tuple>::const_iterator it;
    for ( it=L.begin(); it!=L.end() ; ++it ) {
        cout << setw(8) << it->ID_ENT << " [" << it->REL.ID << ',' << it->REL.SUB << "](";
        cout << it->REL.TYPE << ") " << setw(8) << it->ATTRIB << ' ' << it->VAL.BLOB << endl;
    }
}

void dump_words( const char* name , const ERAV::WORD& W ) {
    std::list<ERAV::WORD_tuple> L;
    W.toList(L);
    if ( L.empty() ) { std::cout << " [ " << name << ".empty() ]\n"; }
    std::list<ERAV::WORD_tuple>::const_iterator it;
    for ( it=L.begin(); it!=L.end() ; ++it ) {
        std::cout << std::setw(8) << it->ID_WORD;
        std::cout << " [" << it->LANG[0] << it->LANG[1] << "] ";
        std::cout << it->DESCR << std::endl;
    }
}

// TD is the test subdirectory for test_ERAV.cpp
const std::string TD = "test/";

void do_megaload() {
    std::fstream COUT;
    std::string XML_adolfo;
    std::list<ERAV::tuple> L;
    ERAV::WORD W,S;
    COUT.open( (TD+"XML_adolfo.bak").c_str() , std::ios_base::out);
    megaload(L,W,S);
    erav2xml(L,W,S,   XML_adolfo );
    erav2xml_enclose( XML_adolfo );
    COUT << XML_adolfo;
    COUT.close();
}

int do_file( const char* name ) {
    int ret=0;
    std::string file = name;
    file = TD + file;
    std::list<ERAV::tuple> L;
    ERAV::WORD W,S;
    std::fstream COUT;
    std::string XML, XML_bak, XML_bak_bak;

    if (false) { ret=test_yylex( file.c_str() ); }
    std::fstream cin( file.c_str() );
    char ch;
    while ( !cin.fail() ) {
        cin.get(ch);
        if (!cin.fail()) { XML += ch; }
    }
    if (false) { std::cout << XML << std::endl; }
    else { std::cout << '\n' << file << " ==============\n\n"; }
    try {
        erav_clear(     L,W,S );
        xml2erav( XML , L,W,S );           // append to L && W && S
        erav2xml(       L,W,S , XML_bak ); // append to XML
        erav2xml_enclose(       XML_bak ); // put header and <erav> tags
        COUT.open(   (file+".bak").c_str() , std::ios_base::out);
        std::cout << (file+".bak").c_str() << std::endl;
        COUT<<XML_bak;
        COUT.close();

        erav_clear(         L,W,S );
        xml2erav( XML_bak , L,W,S );              // append to L && W && S
        erav2xml(           L,W,S, XML_bak_bak ); // append to XML_bak
        erav2xml_enclose(          XML_bak_bak ); // put header and <erav> tags
        COUT.open(   (file+".bak"+".bak").c_str() , std::ios_base::out);
        std::cout << (file+".bak"+".bak").c_str() << std::endl;
        COUT<<XML_bak_bak;
        COUT.close();
    }
    catch ( ERAV::exception e ) { std::cout << e.what(); }
    catch ( ... ) { }
    dump_words( "WORD"   , W );
    dump_words( "STRING" , S );
    dump_tuples( L );
    return ( L.empty() || W.empty() || S.empty() ? 0 : 1 );
}

void load_XML(
    std::string file          , // file to read from
    std::list<ERAV::tuple>& L , // append to current value
    ERAV::WORD&             W , // append to current value
    ERAV::WORD&             S   // append to current value
) {
    std::string  XML;
    std::fstream cin( (TD+file).c_str() );
    char ch;
    while ( !cin.fail() ) {
        cin.get(ch);
        if (!cin.fail()) { XML += ch; }
    }
    try {
        xml2erav( XML , L,W,S ); // append to L && W && S
    }
    catch ( ERAV::exception e ) { std::cout << e.what(); }
    catch ( ... ) { }
}

void do_tuple() {
    std::list<ERAV::tuple> L;
    ERAV::WORD W,S;
    assert( L.empty() && W.empty() && S.empty() );
    for ( int i=0; i<5; ++i ) {
        load_XML( "STRING.xml"   , L , W , S );
        load_XML( "2220222.xml"  , L , W , S );

        load_XML( "ERAV-base.xml", L , W , S );

        load_XML( "WORD.xml"     , L , W , S );
        load_XML( "1110111.xml"  , L , W , S );
    }
    std::string XML_multiple, XML_base;
    erav2xml(   L , W , S , XML_multiple );
    erav_clear( L , W , S );
    xml2erav(   XML_multiple , L , W , S );
    erav2xml(   L , W , S , XML_base );
    if ( XML_base != XML_multiple ) {
        std::cout << "do_tuple() error\n";
    }
    assert( XML_base == XML_multiple );

    erav_clear( L , W , S );
    XML_multiple.clear();
    XML_base.clear();
    std::list<ERAV::tuple>     FROM;
    load_XML( "WORD.xml"     , FROM , W , S ); ERAV::merge_into(L,FROM);
    load_XML( "1110111.xml"  , FROM , W , S ); ERAV::merge_into(L,FROM);
    load_XML( "STRING.xml"   , FROM , W , S ); ERAV::merge_into(L,FROM);
    load_XML( "2220222.xml"  , FROM , W , S ); ERAV::merge_into(L,FROM);
    erav2xml( L , W , S , XML_multiple );

    XML_base.clear();
    erav_clear( L , W , S );
    load_XML( "WORD.xml"     , L , W , S ); erav2xml( L , W , S , XML_base );
    load_XML( "1110111.xml"  , L , W , S ); erav2xml( L , W , S , XML_base );
    load_XML( "STRING.xml"   , L , W , S ); erav2xml( L , W , S , XML_base );
    load_XML( "2220222.xml"  , L , W , S ); erav2xml( L , W , S , XML_base );

    erav_clear( L , W , S );   xml2erav( XML_base , L , W , S );
    XML_base.clear();          erav2xml( L , W , S , XML_base );

    if ( XML_base != XML_multiple ) {
        std::cout << "do_tuple() error\n";
        std::cout << XML_base;
    }
    assert( XML_base == XML_multiple );
}

// Main program.
int main(int argc, char **argv ) {
    char* files[] = {  "noerav.xml",    "test_ERAV.cpp",
                       "ERAV-base.xml", "test_ERAV.cbp", "Adolfo.xml", // 0 1 2
                       "sierav.xml",   "noerav.xml",    "Erav.h",     // 3 4 5
                       "1110111.XML",  "WORD.XML"                  }; // 6 7
    int ret=0;
    do_megaload();

    #define DIM(V) (sizeof(V)/sizeof(*V))
    for ( unsigned i=0; i<DIM(files);++i ) {
        int r = do_file( files[i] );
        ret = ( ret==0 ? r : ret );
    }
    do_tuple();
    return ret;  // ( ! L.empty() ? 0 : 1 )
}

// EOF: test_ERAV.cpp