test/lexer_test.cpp.bk

   1 #include <iostream>
   2 #include <sstream>
   3 #include <string>
   4 #include <functional>
   5
   6 #include "../simpletest.h"
   7
   8 #include "../textarrayformat.h"
   9 #include "../lexeme_id.h"
  10 #include "../reader.h"
  11 #include "../utf8_transcoder.h"
  12 #include "../unicode.h"
  13
  14 #include "../lexer.h"
  15 #include "../lexeme.h"
  16
  17 using namespace std;
  18 using namespace utakata;
  19
  20 bool lexer_test(smart_ptr<simpletest::SimpleTestAsserter> asserter)
  21 {
  22     std::stringstream ss;
  23     ss << "==========" << endl;
  24     ss << "(hoge 12 \"hoge\" )" << endl;
  25
  26     textarrayformat::TextArrayReader reader(ss);
  27     smart_ptr<istream> formats(new stringstream(reader.get()));
  28     smart_ptr<utakata::reader::StreamReader> st(
  29         new utakata::reader::StreamReader(formats,
  30                                           smart_ptr<transcoder::ITranscoder>(
  31                                               new transcoder::UTF8Transcoder())));
  32
  33     utakata::lexer::Lexer lexer;
  34
  35     smart_ptr<lexeme::ILexeme> m(lexer.lex(st));
  36     asserter->checkOnly((*m->toString())[0].getRawCode(), '(');
  37     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::openParenthesis.toEnum(), "open paren");
  38
  39     m = lexer.lex(st);
  40     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier");
  41
  42     m = lexer.lex(st);
  43     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::number.toEnum(), "number");
  44
  45     m = lexer.lex(st);
  46     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::string.toEnum(), "string");
  47
  48     m = lexer.lex(st);
  49     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
  50
  51     // ここで終了しているはず。EOFの状態から実行されると、EOFのIDを持った
  52     // lexemeが返される。
  53     m = lexer.lex(st);
  54     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::eos.toEnum(), "eos");
  55
  56     return asserter->isOk();
  57 }
  58
  59 bool lexer_test2(smart_ptr<simpletest::SimpleTestAsserter> asserter)
  60 {
  61     std::stringstream ss;
  62     ss << "==========" << endl;
  63     ss << ",@(hoge 12 `(hoge) 'huga #f #t)" << endl;
  64
  65
  66     textarrayformat::TextArrayReader reader(ss);
  67     smart_ptr<istream> formats(new stringstream(reader.get()));
  68     smart_ptr<utakata::reader::StreamReader> st(
  69         new utakata::reader::StreamReader(formats,
  70                                           smart_ptr<transcoder::ITranscoder>(
  71                                               new transcoder::UTF8Transcoder())));
  72
  73     utakata::lexer::Lexer lexer;
  74
  75     smart_ptr<lexeme::ILexeme> m(lexer.lex(st));
  76     asserter->checkOnly((*m->toString())[0].getRawCode(), ',');
  77
  78     m = lexer.lex(st);
  79     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::openParenthesis.toEnum(), "open paren");
  80
  81     m = lexer.lex(st);
  82     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier");
  83
  84     m = lexer.lex(st);
  85     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::number.toEnum(), "number");
  86
  87     m = lexer.lex(st);
  88     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::backquote.toEnum(), "back quote");
  89
  90     m = lexer.lex(st);
  91     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::openParenthesis.toEnum(), "open paren2");
  92
  93     m = lexer.lex(st);
  94     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier2");
  95
  96     m = lexer.lex(st);
  97     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
  98
  99     m = lexer.lex(st);
 100     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::quote.toEnum(), "quote");
 101
 102     m = lexer.lex(st);
 103     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier2");
 104
 105     // booleanの解析が行えるかどうか。
 106     m = lexer.lex(st);
 107     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::boolean.toEnum(), "boolean:false");
 108     m = lexer.lex(st);
 109     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::boolean.toEnum(), "boolean:true");
 110
 111     m = lexer.lex(st);
 112     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
 113
 114     // ここで終了しているはず。EOFの状態から実行されると、EOFのIDを持った
 115     // lexemeが返される。
 116     m = lexer.lex(st);
 117     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::eos.toEnum(), "eos");
 118
 119     return asserter->isOk();
 120 }
 121
 122 bool lexer_test3(smart_ptr<simpletest::SimpleTestAsserter> asserter)
 123 {
 124     std::stringstream ss;
 125     ss << "==========" << endl;
 126     ss << "#'(hoge #,12 #`(hoge) 'huga) ; comment" << endl;
 127     ss << "hoge #vu8(12 12) #(vector)" << endl;
 128
 129     textarrayformat::TextArrayReader reader(ss);
 130     smart_ptr<istream> formats(new stringstream(reader.get()));
 131     smart_ptr<utakata::reader::StreamReader> st(
 132         new utakata::reader::StreamReader(formats,
 133                                           smart_ptr<transcoder::ITranscoder>(
 134                                               new transcoder::UTF8Transcoder())));
 135     utakata::lexer::Lexer lexer;
 136
 137     smart_ptr<lexeme::ILexeme> m(lexer.lex(st));
 138     asserter->checkOnly((*m->toString())[0].getRawCode(), '#', "syntax");
 139
 140     m = lexer.lex(st);
 141     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::openParenthesis.toEnum(), "open paren");
 142
 143     m = lexer.lex(st);
 144     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier");
 145
 146     m = lexer.lex(st);
 147     asserter->checkOnly((*m->toString())[1].getRawCode(), ',', "unsyntax");
 148     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::unsyntax.toEnum(), "unsyntax");
 149
 150     m = lexer.lex(st);
 151     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::number.toEnum(), "number");
 152
 153     m = lexer.lex(st);
 154     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::quasiSyntax.toEnum(), "quasi syntax");
 155
 156     m = lexer.lex(st);
 157     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::openParenthesis.toEnum(), "open paren2");
 158
 159     m = lexer.lex(st);
 160     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier2");
 161
 162     m = lexer.lex(st);
 163     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
 164
 165     m = lexer.lex(st);
 166     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::quote.toEnum(), "quote");
 167
 168     m = lexer.lex(st);
 169     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier2");
 170
 171     m = lexer.lex(st);
 172     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
 173
 174     m = lexer.lex(st);
 175     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "identifier3");
 176
 177     m = lexer.lex(st);
 178     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::byteVector.toEnum(), "byteVector");
 179     m = lexer.lex(st);
 180     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::number.toEnum(), "byteVector:number1");
 181     m = lexer.lex(st);
 182     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::number.toEnum(), "byteVector:number2");
 183     m = lexer.lex(st);
 184     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
 185
 186     m = lexer.lex(st);
 187     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::vector.toEnum(), "vector");
 188     m = lexer.lex(st);
 189     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::identifier.toEnum(), "vector:identifier");
 190     m = lexer.lex(st);
 191     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::closeParenthesis.toEnum(), "close");
 192
 193     // ここで終了しているはず。EOFの状態から実行されると、EOFのIDを持った
 194     // lexemeが返される。
 195     m = lexer.lex(st);
 196     asserter->checkOnly(m->getID().toEnum(), lexeme::LexemeID::eos.toEnum(), "eos");
 197
 198     return asserter->isOk();
 199 }
 200
 201
 202 int main(int argc, char *argv[])
 203 {
 204     simpletest::SimpleTestSuite suite("main lexer test");
 205     suite.addTester(sfcr::screate(lexer_test, suite.getAsserter()));
 206     suite.addTester(sfcr::screate(lexer_test2, suite.getAsserter()));
 207     suite.addTester(sfcr::screate(lexer_test3, suite.getAsserter()));
 208     suite.run();
 209     return 0;
 210 }