test/identifier_lexer_test.cpp

   1 #include <test/gtest/gtest.h>
   2 #include "lib/textarrayformat.h"
   3 #include "src/lexer/identifier_lexer.h"
   4 #include "src/encoding_reader.h"
   5 #include "src/string_reader.h"
   6 #include "src/unicode.h"
   7 #include "lib/scoped_ptr.h"
   8 #include "src/utf8_transcoder.h"
   9 #include "src/lexeme.h"
  10
  11 namespace textarrayformat = utility::textarrayformat;
  12 namespace lexer = utakata::lexer;
  13 namespace unicode = utakata::unicode;
  14 namespace reader = utakata::reader;
  15 namespace transcoder = utakata::transcoder;
  16
  17 class IdentifierLexerTest : public ::testing::Test {
  18  protected:
  19   virtual void SetUp() {
  20     gen.reset(new textarrayformat::TextArrayGenerator("========="));
  21     gen->Punctuate("lambda q soup");
  22     gen->Punctuate("list->vector + ->-");
  23     gen->Punctuate("<= a34kTMNs?");
  24     gen->Punctuate("the-word-recursion-has-maney-meanings");
  25     gen->Punctuate("!$%&*+-./:?@^_~");
  26     gen->Punctuate("\\x0061;iueo ab\\x63;d");
  27     gen->Punctuate("-- +> string+ ... ...s");
  28   }
  29
  30   akebono::scoped_ptr<textarrayformat::TextArrayGenerator> gen;
  31 };
  32
  33 TEST_F(IdentifierLexerTest, NormalIdentifer) {
  34   textarrayformat::TextArrayReader textarray(*gen);
  35
  36   reader::StringReader sr(textarray.GetBlockAt(0));
  37   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
  38   lexer::IdentifierLexer lexer;
  39
  40   akebono::scoped_ptr<lexer::Lexeme> l(lexer.Lex(&reader));
  41   EXPECT_TRUE(l.get() != NULL);
  42   EXPECT_TRUE(l->string() == unicode::Convert("lambda"));
  43   EXPECT_EQ(l->string().GetSize(), 6);
  44   EXPECT_EQ(l->type(), lexer::Lexeme::kIdentifier);
  45
  46   reader.Read();
  47   l.reset(lexer.Lex(&reader));
  48   EXPECT_TRUE(l.get() != NULL);
  49   EXPECT_TRUE(l->string() == unicode::Convert("q"));
  50   EXPECT_EQ(l->string().GetSize(), 1);
  51   EXPECT_EQ(l->type(), lexer::Lexeme::kIdentifier);
  52
  53   reader.Read();
  54   l.reset(lexer.Lex(&reader));
  55   EXPECT_TRUE(l.get() != NULL);
  56   EXPECT_TRUE(l->string() == unicode::Convert("soup"));
  57   EXPECT_EQ(l->string().GetSize(), 4);
  58   EXPECT_EQ(l->type(), lexer::Lexeme::kIdentifier);
  59 }
  60
  61
  62 TEST_F(IdentifierLexerTest, IgnoreCapital) {
  63   textarrayformat::TextArrayReader textarray(*gen);
  64
  65   reader::StringReader sr(textarray.GetBlockAt(2));
  66   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
  67
  68   lexer::IdentifierLexer lexer;
  69   akebono::scoped_ptr<lexer::Lexeme> l(lexer.Lex(&reader));
  70   EXPECT_TRUE(l.get() != NULL);
  71   EXPECT_TRUE(l->string() == unicode::Convert("<="));
  72   EXPECT_EQ(l->string().GetSize(), 2);
  73   EXPECT_EQ(l->type(), lexer::Lexeme::kIdentifier);
  74
  75   reader.Read();
  76   l.reset(lexer.Lex(&reader));
  77   EXPECT_TRUE(l.get() != NULL);
  78   EXPECT_TRUE(l->string() == unicode::Convert("a34kTMNs?"));
  79   EXPECT_EQ(l->string().GetSize(), 9);
  80   EXPECT_EQ(l->type(), lexer::Lexeme::kIdentifier);
  81 }
  82
  83 TEST_F(IdentifierLexerTest, LongIdentifer) {
  84   textarrayformat::TextArrayReader textarray(*gen);
  85
  86   reader::StringReader sr(textarray.GetBlockAt(3));
  87   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
  88   lexer::IdentifierLexer lexer;
  89
  90   akebono::scoped_ptr<lexer::Lexeme> l(lexer.Lex(&reader));
  91   EXPECT_TRUE(l.get() != NULL);
  92   EXPECT_TRUE(l->string() == unicode::Convert(
  93       "the-word-recursion-has-maney-meanings"));
  94   EXPECT_EQ(l->string().GetSize(), 37);
  95   EXPECT_EQ(l->type(), lexer::Lexeme::kIdentifier);
  96 }
  97
  98 TEST_F(IdentifierLexerTest, SpecialInitials) {
  99   textarrayformat::TextArrayReader textarray(*gen);
 100
 101   reader::StringReader sr(textarray.GetBlockAt(4));
 102   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 103   lexer::IdentifierLexer lexer;
 104
 105   akebono::scoped_ptr<lexer::Lexeme> l(lexer.Lex(&reader));
 106   EXPECT_TRUE(l.get() != NULL);
 107   EXPECT_TRUE(l->string() == unicode::Convert("!$%&*+-./:?@^_~"));
 108   EXPECT_EQ(l->string().GetSize(), 15);
 109 }
 110
 111 TEST_F(IdentifierLexerTest, InlineEscape) {
 112   textarrayformat::TextArrayReader textarray(*gen);
 113
 114   reader::StringReader sr(textarray.GetBlockAt(5));
 115   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 116   lexer::IdentifierLexer lexer;
 117
 118   akebono::scoped_ptr<lexer::Lexeme> l(lexer.Lex(&reader));
 119   EXPECT_TRUE(l.get() != NULL);
 120   EXPECT_TRUE(l->string() == unicode::Convert("aiueo"));
 121   EXPECT_EQ(l->string().GetSize(), 5);
 122
 123   reader.Read();
 124   l.reset(lexer.Lex(&reader));
 125   EXPECT_TRUE(l.get() != NULL);
 126   EXPECT_TRUE(l->string() == unicode::Convert("abcd"));
 127   EXPECT_EQ(l->string().GetSize(), 4);
 128 }
 129
 130 TEST_F(IdentifierLexerTest, Errors) {
 131   textarrayformat::TextArrayReader textarray(*gen);
 132
 133   reader::StringReader sr(textarray.GetBlockAt(6));
 134   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 135   lexer::IdentifierLexer lexer;
 136
 137   akebono::scoped_ptr<lexer::Lexeme> l;
 138   EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 139
 140   reader.Read(2);
 141   EXPECT_THROW(l.reset(lexer.Lex(&reader)), lexer::LexException);
 142
 143   reader.Read(2);
 144   EXPECT_NO_THROW(l.reset(lexer.Lex(&reader)));
 145
 146   reader.Read();
 147   EXPECT_NO_THROW(l.reset(lexer.Lex(&reader)));
 148   EXPECT_TRUE(l.get() != NULL);
 149   EXPECT_TRUE(l->string() == unicode::Convert("..."));
 150   EXPECT_EQ(l->string().GetSize(), 3);
 151
 152   reader.Read();
 153   EXPECT_THROW(l.reset(lexer.Lex(&reader)), lexer::LexException);
 154 }
 155
 156 int main(int argc, char** argv) {
 157   testing::InitGoogleTest(&argc, argv);
 158   return RUN_ALL_TESTS();
 159 }