test/charactor_lexer_test.cpp

   1 #include <test/gtest/gtest.h>
   2 #include "lib/textarrayformat.h"
   3 #include "src/lexer/charactor_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 "lib/smart_ptr.h"
   9 #include "src/utf8_transcoder.h"
  10 #include "src/lexer/token.h"
  11
  12 namespace textarrayformat = utility::textarrayformat;
  13 namespace lexer = utakata::lexer;
  14 namespace unicode = utakata::unicode;
  15 namespace reader = utakata::reader;
  16 namespace transcoder = utakata::transcoder;
  17
  18 class CharactorLexerTest : public ::testing::Test {
  19  protected:
  20   virtual void SetUp() {
  21     gen.reset(new textarrayformat::TextArrayGenerator("========="));
  22     gen->Punctuate("#\\a #\\z #\\x( #\\xo");
  23     gen->Punctuate("#\\x001 #\\x7f8f");
  24     gen->Punctuate("#\\nul");
  25     gen->Punctuate("#\\alarm");
  26     gen->Punctuate("#\\backspace");
  27     gen->Punctuate("#\\tab #\\linefeed");
  28     gen->Punctuate("#\\newline #\\vtab #\\page");
  29     gen->Punctuate(std::string("#\\return #\\esc") + std::string("\n")
  30                    + std::string("#\\space"));
  31     gen->Punctuate("#\\delete");
  32   }
  33
  34   akebono::scoped_ptr<textarrayformat::TextArrayGenerator> gen;
  35 };
  36
  37 TEST_F(CharactorLexerTest, SingleCharactorLex) {
  38   textarrayformat::TextArrayReader textarray(*gen);
  39
  40   reader::StringReader sr(textarray.GetBlockAt(0));
  41   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
  42
  43   lexer::CharactorLexer lexer;
  44   akebono::smart_ptr<lexer::Token> l(lexer.Lex(&reader));
  45   EXPECT_TRUE(l.get() != NULL);
  46   EXPECT_EQ(l->string().At(0).rawcode(), 'a');
  47   EXPECT_EQ(l->string().GetSize(), 1);
  48   EXPECT_EQ(l->type(), lexer::Token::kCharactor);
  49
  50   reader.Read();
  51   l = lexer.Lex(&reader);
  52   EXPECT_TRUE(l.get() != NULL);
  53   EXPECT_EQ(l->string().At(0).rawcode(), 'z');
  54   EXPECT_EQ(l->string().GetSize(), 1);
  55   EXPECT_EQ(l->type(), lexer::Token::kCharactor);
  56
  57   reader.Read();
  58   l = lexer.Lex(&reader);
  59   EXPECT_TRUE(l.get() != NULL);
  60   EXPECT_EQ(l->string().At(0).rawcode(), 'x');
  61   EXPECT_EQ(l->string().GetSize(), 1);
  62   EXPECT_EQ(l->type(), lexer::Token::kCharactor);
  63
  64   reader.Read(2);
  65   EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
  66 }
  67
  68 TEST_F(CharactorLexerTest, HexCharactorTest) {
  69   textarrayformat::TextArrayReader textarray(*gen);
  70
  71   reader::StringReader sr(textarray.GetBlockAt(1));
  72   reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
  73
  74   lexer::CharactorLexer lexer;
  75   akebono::smart_ptr<lexer::Token> l;
  76
  77   l = lexer.Lex(&reader);
  78   EXPECT_TRUE(l.get() != NULL);
  79   EXPECT_EQ(l->string().At(0).rawcode(), 0x01);
  80   EXPECT_EQ(l->string().GetSize(), 1);
  81   EXPECT_EQ(l->type(), lexer::Token::kCharactor);
  82
  83   reader.Read();
  84   l = lexer.Lex(&reader);
  85   EXPECT_TRUE(l.get() != NULL);
  86   EXPECT_EQ(l->string().At(0).rawcode(), 0x7f8f);
  87   EXPECT_EQ(l->string().GetSize(), 1);
  88   EXPECT_EQ(l->type(), lexer::Token::kCharactor);
  89 }
  90
  91 TEST_F(CharactorLexerTest, NameLexingNul) {
  92   textarrayformat::TextArrayReader textarray(*gen);
  93   akebono::smart_ptr<lexer::Token> l;
  94   {
  95     reader::StringReader sr(textarray.GetBlockAt(2));
  96     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
  97     lexer::CharactorLexer lexer;
  98
  99     l = lexer.Lex(&reader);
 100     EXPECT_TRUE(l.get() != NULL);
 101     EXPECT_EQ(l->string().At(0).rawcode(), 0x0);
 102     EXPECT_EQ(l->string().GetSize(), 1);
 103   }
 104
 105   {
 106     reader::StringReader sr("#\\null");
 107     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 108     lexer::CharactorLexer lexer;
 109
 110     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 111   }
 112
 113   {
 114     reader::StringReader sr("#\\nu");
 115     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 116     lexer::CharactorLexer lexer;
 117     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 118   }
 119 }
 120
 121 TEST_F(CharactorLexerTest, NameLexingAlarm) {
 122   textarrayformat::TextArrayReader textarray(*gen);
 123   akebono::smart_ptr<lexer::Token> l;
 124   {
 125     reader::StringReader sr(textarray.GetBlockAt(3));
 126     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 127     lexer::CharactorLexer lexer;
 128
 129     l = lexer.Lex(&reader);
 130     EXPECT_TRUE(l.get() != NULL);
 131     EXPECT_EQ(l->string().At(0).rawcode(), 0x07);
 132     EXPECT_EQ(l->string().GetSize(), 1);
 133   }
 134
 135   {
 136     reader::StringReader sr("#\\alar");
 137     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 138     lexer::CharactorLexer lexer;
 139
 140     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 141   }
 142
 143   {
 144     reader::StringReader sr("#\\alarms");
 145     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 146     lexer::CharactorLexer lexer;
 147     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 148   }
 149 }
 150
 151 TEST_F(CharactorLexerTest, NameLexingBackspace) {
 152   textarrayformat::TextArrayReader textarray(*gen);
 153   akebono::smart_ptr<lexer::Token> l;
 154   {
 155     reader::StringReader sr(textarray.GetBlockAt(4));
 156     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 157     lexer::CharactorLexer lexer;
 158
 159     l = lexer.Lex(&reader);
 160     EXPECT_TRUE(l.get() != NULL);
 161     EXPECT_EQ(l->string().At(0).rawcode(), 0x08);
 162     EXPECT_EQ(l->string().GetSize(), 1);
 163   }
 164
 165   {
 166     reader::StringReader sr("#\\Backspace");
 167     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 168     lexer::CharactorLexer lexer;
 169
 170     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 171   }
 172
 173   {
 174     reader::StringReader sr("#\\backspa");
 175     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 176     lexer::CharactorLexer lexer;
 177     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 178   }
 179 }
 180
 181 TEST_F(CharactorLexerTest, NameLexingTabAndLinefeed) {
 182   textarrayformat::TextArrayReader textarray(*gen);
 183   akebono::smart_ptr<lexer::Token> l;
 184   {
 185     reader::StringReader sr(textarray.GetBlockAt(5));
 186     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 187     lexer::CharactorLexer lexer;
 188
 189     l = lexer.Lex(&reader);
 190     EXPECT_TRUE(l.get() != NULL);
 191     EXPECT_EQ(l->string().At(0).rawcode(), 0x09);
 192     EXPECT_EQ(l->string().GetSize(), 1);
 193
 194     reader.Read();
 195     l = lexer.Lex(&reader);
 196     EXPECT_TRUE(l.get() != NULL);
 197     EXPECT_EQ(l->string().At(0).rawcode(), 0x0a);
 198     EXPECT_EQ(l->string().GetSize(), 1);
 199   }
 200
 201   {
 202     reader::StringReader sr("#\\Tab");
 203     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 204     lexer::CharactorLexer lexer;
 205
 206     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 207   }
 208
 209   {
 210     reader::StringReader sr("#\\line");
 211     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 212     lexer::CharactorLexer lexer;
 213     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 214   }
 215 }
 216
 217 TEST_F(CharactorLexerTest, NameLexing) {
 218   textarrayformat::TextArrayReader textarray(*gen);
 219   akebono::smart_ptr<lexer::Token> l;
 220   {
 221     reader::StringReader sr(textarray.GetBlockAt(6));
 222     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 223     lexer::CharactorLexer lexer;
 224
 225     l = lexer.Lex(&reader);
 226     EXPECT_TRUE(l.get() != NULL);
 227     EXPECT_EQ(l->string().At(0).rawcode(), 0x0A);
 228     EXPECT_EQ(l->string().GetSize(), 1);
 229
 230     reader.Read();
 231     l = lexer.Lex(&reader);
 232     EXPECT_TRUE(l.get() != NULL);
 233     EXPECT_EQ(l->string().At(0).rawcode(), 0x0B);
 234     EXPECT_EQ(l->string().GetSize(), 1);
 235
 236     reader.Read();
 237     l = lexer.Lex(&reader);
 238     EXPECT_TRUE(l.get() != NULL);
 239     EXPECT_EQ(l->string().At(0).rawcode(), 0x0C);
 240     EXPECT_EQ(l->string().GetSize(), 1);
 241   }
 242
 243   {
 244     reader::StringReader sr(textarray.GetBlockAt(7));
 245     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 246     lexer::CharactorLexer lexer;
 247
 248     l = lexer.Lex(&reader);
 249     EXPECT_TRUE(l.get() != NULL);
 250     EXPECT_EQ(l->string().At(0).rawcode(), 0x0D);
 251     EXPECT_EQ(l->string().GetSize(), 1);
 252
 253     reader.Read();
 254     l = lexer.Lex(&reader);
 255     EXPECT_TRUE(l.get() != NULL);
 256     EXPECT_EQ(l->string().At(0).rawcode(), 0x1B);
 257     EXPECT_EQ(l->string().GetSize(), 1);
 258
 259     reader.Read();
 260     l = lexer.Lex(&reader);
 261     EXPECT_TRUE(l.get() != NULL);
 262     EXPECT_EQ(l->string().At(0).rawcode(), 0x20);
 263     EXPECT_EQ(l->string().GetSize(), 1);
 264   }
 265 }
 266
 267 TEST_F(CharactorLexerTest, NameLexingDelete) {
 268   textarrayformat::TextArrayReader textarray(*gen);
 269   akebono::smart_ptr<lexer::Token> l;
 270   {
 271     reader::StringReader sr(textarray.GetBlockAt(8));
 272     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 273     lexer::CharactorLexer lexer;
 274
 275     l = lexer.Lex(&reader);
 276     EXPECT_TRUE(l.get() != NULL);
 277     EXPECT_EQ(l->string().At(0).rawcode(), 0x7f);
 278     EXPECT_EQ(l->string().GetSize(), 1);
 279   }
 280
 281   {
 282     reader::StringReader sr("#\\del");
 283     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 284     lexer::CharactorLexer lexer;
 285
 286     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 287   }
 288
 289   {
 290     reader::StringReader sr("#\\Delete");
 291     reader::EncodingReader reader(&sr, new transcoder::UTF8Transcoder);
 292     lexer::CharactorLexer lexer;
 293     EXPECT_THROW(lexer.Lex(&reader), lexer::LexException);
 294   }
 295 }
 296
 297 int main(int argc, char** argv) {
 298   testing::InitGoogleTest(&argc, argv);
 299   return RUN_ALL_TESTS();
 300 }