PageRenderTime 53ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/src/com/xruby/compiler/parser/RubyLexerTest.java

http://xruby.googlecode.com/
Java | 1573 lines | 1261 code | 221 blank | 91 comment | 4 complexity | 09732faece5899bf65bd04b6c971849b MD5 | raw file
Possible License(s): Apache-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. /**

    2. 

  2.  * Copyright 2005-2007 Xue Yong Zhi

    3. 

  3.  * Distributed under the Apache License

    4. 

  4.  */

    5. 

  5. 

    6. 

  6. package com.xruby.compiler.parser;

    7. 

  7. 

    8. 

  8. import java.io.*;

    9. 

  9. import junit.framework.*;

    10. 

  10. import antlr.Token;

    11. 

  11. import antlr.TokenStreamException;

    12. 

  12. import antlr.CommonToken;

    13. 

  13. 

    14. 

  14. class TestingCommonToken extends CommonToken {

    15. 

  15.     public TestingCommonToken(int t, String txt) {

    16. 

  16.         super(t, txt);

    17. 

  17.         setLine(1);

    18. 

  18.     }

    19. 

  19. 

    20. 

  20.     public TestingCommonToken(int t, String txt, int line) {

    21. 

  21.         super(t, txt);

    22. 

  22.         setLine(line);

    23. 

  23.     }

    24. 

  24. }

    25. 

  25. 

    26. 

  26. public class RubyLexerTest extends TestCase implements RubyTokenTypes {

    27. 

  27. 

    28. 

  28.     private void assert_type(String[] program_texts, int expected_type, String[] expected_texts) {

    29. 

  29.         assertEquals("Length mismatch, setup expected_texts properly!", program_texts.length, expected_texts.length);

    30. 

  30. 

    31. 

  31.         for (int i = 0; i < program_texts.length; ++i) {

    32. 

  32.             try {

    33. 

  33.                 RubyLexer lexer = new RubyLexer(new StringReader(program_texts[i]), false);

    34. 

  34.                 Token token = lexer.nextToken();

    35. 

  35.                 assertEquals(program_texts[i], expected_type, token.getType());

    36. 

  36. 

    37. 

  37.                 assertEquals(program_texts[i], expected_texts[i], token.getText());

    38. 

  38. 

    39. 

  39.                 // should contain only one token

    40. 

  40.                 if (Token.EOF_TYPE == token.getType()) {

    41. 

  41.                     Token next_token = lexer.nextToken();

    42. 

  42.                     assertEquals(program_texts[i] + "contains multiple tokens!", Token.EOF_TYPE, next_token.getType());

    43. 

  43.                 }

    44. 

  44.             } catch (TokenStreamException e) {

    45. 

  45.                 assertTrue(program_texts[i]+ e.toString(), false);

    46. 

  46.             }

    47. 

  47.         }

    48. 

  48.     }

    49. 

  49. 

    50. 

  50.     private void assert_type(String[] program_texts, int expected_type) {

    51. 

  51.         assert_type(program_texts, expected_type, program_texts);

    52. 

  52.     }

    53. 

  53. 

    54. 

  54.     private void assert_type(String program_text, int expected_type, String expected_text) {

    55. 

  55.         try {

    56. 

  56.             RubyLexer lexer = new RubyLexer(new StringReader(program_text), false);

    57. 

  57.             Token token = lexer.nextToken();

    58. 

  58.             assertEquals(program_text, expected_type, token.getType());

    59. 

  59.             assertEquals(program_text, expected_text, token.getText());

    60. 

  60.         } catch (TokenStreamException e) {

    61. 

  61.             assertTrue(program_text + e.toString(), false);

    62. 

  62.         }

    63. 

  63. 

    64. 

  64.     }

    65. 

  65. 

    66. 

  66.     private void assert_type(String program_text, TestingCommonToken[] tokens) {

    67. 

  67.         try {

    68. 

  68.             RubyLexer lexer = new RubyLexer(new StringReader(program_text), false);

    69. 

  69. 

    70. 

  70.             for (int i = 0; i < tokens.length; ++i) {

    71. 

  71.                 Token token = lexer.nextToken();

    72. 

  72.                 assertEquals(i + " " + token.getText() + " has wrong type!", tokens[i].getType(), token.getType());

    73. 

  73.                 assertEquals(i + " " + token.getText() + " has wrong text!", tokens[i].getText(), token.getText());

    74. 

  74.                 assertEquals(i + " " + token.getText() + " has wrong position!", tokens[i].getLine(), token.getLine());

    75. 

  75.             }

    76. 

  76. 

    77. 

  77.             Token token = lexer.nextToken();

    78. 

  78.             assertEquals("should have no token left!", token.getType(), Token.EOF_TYPE);

    79. 

  79.         } catch (TokenStreamException e) {

    80. 

  80.             assertTrue(program_text + e.toString(), false);

    81. 

  81.         }

    82. 

  82.     }

    83. 

  83. 

    84. 

  84.     private void assert_type(String program_text, int expected_type) {

    85. 

  85.         assert_type(program_text, expected_type, program_text);

    86. 

  86.     }

    87. 

  87. 

    88. 

  88.     public void test_token_stream1() {

    89. 

  89.         String program_text = "puts \"hello\";";

    90. 

  90.         TestingCommonToken[] token_types =  {

    91. 

  91.                             new TestingCommonToken(FUNCTION, "puts"),

    92. 

  92.                             new TestingCommonToken(DOUBLE_QUOTE_STRING, "hello"),

    93. 

  93.                             new TestingCommonToken(SEMI, ";"),

    94. 

  94.         };

    95. 

  95. 

    96. 

  96.         assert_type(program_text, token_types);

    97. 

  97.     }

    98. 

  98. 

    99. 

  99.     public void test_token_stream2() {

    100. 

  100.         String program_text = "0.step";

    101. 

  101.         TestingCommonToken[] token_types =  {

    102. 

  102.                             new TestingCommonToken(INTEGER, "0"),

    103. 

  103.                             new TestingCommonToken(DOT, "."),

    104. 

  104.                             new TestingCommonToken(FUNCTION, "step"),

    105. 

  105.         };

    106. 

  106. 

    107. 

  107.         assert_type(program_text, token_types);

    108. 

  108.     }

    109. 

  109. 

    110. 

  110.     public void test_token_stream3() {

    111. 

  111.         String program_text = "$?/256";

    112. 

  112.         TestingCommonToken[] token_types =  {

    113. 

  113.                             new TestingCommonToken(GLOBAL_VARIABLE , "$?"),

    114. 

  114.                             new TestingCommonToken(DIV, "/"),

    115. 

  115.                             new TestingCommonToken(INTEGER, "256"),

    116. 

  116.         };

    117. 

  117. 

    118. 

  118.         assert_type(program_text, token_types);

    119. 

  119.     }

    120. 

  120. 

    121. 

  121.     public void test_token_stream4() {

    122. 

  122.         String program_text = " def /(item)";

    123. 

  123.         TestingCommonToken[] token_types =  {

    124. 

  124.                             new TestingCommonToken(LITERAL_def, "def"),

    125. 

  125.                             new TestingCommonToken(DIV, "/"),

    126. 

  126.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    127. 

  127.                             new TestingCommonToken(FUNCTION, "item"),

    128. 

  128.                             new TestingCommonToken(RPAREN, ")"),

    129. 

  129.         };

    130. 

  130. 

    131. 

  131.         assert_type(program_text, token_types);

    132. 

  132.     }

    133. 

  133. 

    134. 

  134.     public void test_token_stream5() {

    135. 

  135.         String program_text = "def -@(); end";

    136. 

  136.         TestingCommonToken[] token_types =  {

    137. 

  137.                             new TestingCommonToken(LITERAL_def, "def"),

    138. 

  138.                             new TestingCommonToken(UNARY_PLUS_MINUS_METHOD_NAME, "-@"),

    139. 

  139.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    140. 

  140.                             new TestingCommonToken(RPAREN, ")"),

    141. 

  141.                             new TestingCommonToken(SEMI, ";"),

    142. 

  142.                             new TestingCommonToken(LITERAL_end, "end"),

    143. 

  143.         };

    144. 

  144. 

    145. 

  145.         assert_type(program_text, token_types);

    146. 

  146.     }

    147. 

  147. 

    148. 

  148.     /*need parser

    149. 

  149.     public void test_token_stream6() {

    150. 

  150.         String program_text = "puts <<EOS\n" +

    151. 

  151. "Usage: #{123} [--key keypair_file] name\n"	+

    152. 

  152. "  name ... ex. /C=JP/O=RRR/OU=CA/CN=NaHi/emailAddress=nahi@example.org\n" +

    153. 

  153. "EOS\n";

    154. 

  154.         TestingCommonToken[] token_types =  {

    155. 

  155.                             new TestingCommonToken(FUNCTION, "puts"),

    156. 

  156.                             new TestingCommonToken(HERE_DOC_BEGIN, "EOS"),

    157. 

  157.                             new TestingCommonToken(HERE_DOC_BEFORE_EXPRESSION_SUBSTITUTION, "Usage: "),

    158. 

  158.                             new TestingCommonToken(LCURLY_BLOCK, "{"),

    159. 

  159.                             new TestingCommonToken(INTEGER, "123"),

    160. 

  160.                             new TestingCommonToken(RCURLY, "}"),

    161. 

  161.                             new TestingCommonToken(HERE_DOC_AFTER_EXPRESSION_SUBSTITUTION, " [--key keypair_file] name\n" +

    162. 

  162.                             "  name ... ex. /C=JP/O=RRR/OU=CA/CN=NaHi/emailAddress=nahi@example.org\n"),

    163. 

  163.                             new TestingCommonToken(LINE_BREAK, "\n", 4),

    164. 

  164.         };

    165. 

  165. 

    166. 

  166.         assert_type(program_text, token_types);

    167. 

  167.     }*/

    168. 

  168. 

    169. 

  169.     public void test_token_stream7() {

    170. 

  170.         String program_text =

    171. 

  171. "    res.body =<<-_end_of_html_\r\n"	+

    172. 

  172. "      <HTML/>\n"	+

    173. 

  173. "    _end_of_html_\n";

    174. 

  174. 

    175. 

  175.         TestingCommonToken[] token_types =  {

    176. 

  176.                             new TestingCommonToken(FUNCTION, "res"),

    177. 

  177.                             new TestingCommonToken(DOT, "."),

    178. 

  178.                             new TestingCommonToken(FUNCTION, "body"),

    179. 

  179.                             new TestingCommonToken(ASSIGN, "="),

    180. 

  180.                             new TestingCommonToken(HERE_DOC_BEGIN, "-_end_of_html_"),

    181. 

  181.                             new TestingCommonToken(HERE_DOC_CONTENT, "      <HTML/>\n"),

    182. 

  182.                             new TestingCommonToken(LINE_BREAK, "\n", 3),

    183. 

  183.         };

    184. 

  184. 

    185. 

  185.         assert_type(program_text, token_types);

    186. 

  186.     }

    187. 

  187. 

    188. 

  188.     public void test_token_stream8() {

    189. 

  189.         String program_text =

    190. 

  190. "\r\nres.body = <<-_end_of_html_\n"	+

    191. 

  191. "    _end_of_html_\n";

    192. 

  192. 

    193. 

  193.         TestingCommonToken[] token_types =  {

    194. 

  194.                             new TestingCommonToken(LINE_BREAK, "\n", 1),

    195. 

  195.                             new TestingCommonToken(FUNCTION, "res", 2),

    196. 

  196.                             new TestingCommonToken(DOT, ".", 2),

    197. 

  197.                             new TestingCommonToken(FUNCTION, "body", 2),

    198. 

  198.                             new TestingCommonToken(ASSIGN, "=", 2),

    199. 

  199.                             new TestingCommonToken(HERE_DOC_BEGIN, "-_end_of_html_", 2),

    200. 

  200.                             new TestingCommonToken(HERE_DOC_CONTENT, "", 2),

    201. 

  201.                             new TestingCommonToken(LINE_BREAK, "\n", 3),

    202. 

  202.         };

    203. 

  203. 

    204. 

  204.         assert_type(program_text, token_types);

    205. 

  205.     }

    206. 

  206. 

    207. 

  207.     public void test_token_stream9() {

    208. 

  208.         String program_text = "\n\n\nunless /{$1}\\z/o =~ s";

    209. 

  209. 

    210. 

  210.         TestingCommonToken[] token_types =  {

    211. 

  211.                             new TestingCommonToken(LINE_BREAK, "\n", 1),

    212. 

  212.                             new TestingCommonToken(LITERAL_unless, "unless", 4),

    213. 

  213.                             new TestingCommonToken(REGEX, "{$1}\\z/o", 4),

    214. 

  214.                             new TestingCommonToken(MATCH, "=~", 4),

    215. 

  215.                             new TestingCommonToken(FUNCTION, "s", 4),

    216. 

  216.         };

    217. 

  217. 

    218. 

  218.         assert_type(program_text, token_types);

    219. 

  219.     }

    220. 

  220. 

    221. 

  221.     public void test_token_stream10() {

    222. 

  222.         String program_text = "  when /^#/" +

    223. 

  223. "    raise \"unknown node type: '{ntype}'\"";

    224. 

  224. 

    225. 

  225.         TestingCommonToken[] token_types =  {

    226. 

  226.                             new TestingCommonToken(LITERAL_when, "when"),

    227. 

  227.                             new TestingCommonToken(REGEX, "^#/"),

    228. 

  228.                             new TestingCommonToken(FUNCTION, "raise"),

    229. 

  229.                             new TestingCommonToken(DOUBLE_QUOTE_STRING, "unknown node type: '{ntype}'"),

    230. 

  230.         };

    231. 

  231. 

    232. 

  232.         assert_type(program_text, token_types);

    233. 

  233.     }

    234. 

  234. 

    235. 

  235.     public void test_token_stream11() {

    236. 

  236.         String program_text = "def log_src(src)\n"	+

    237. 

  237. "  Logging::puts <<\"EOM\", src\n"	+

    238. 

  238. "checked program was:\n"	+

    239. 

  239. "/* begin */\n"	+

    240. 

  240. "%s/* end */\n\n"+

    241. 

  241. "EOM\n"	+

    242. 

  242. "end";

    243. 

  243. 

    244. 

  244.         TestingCommonToken[] token_types =  {

    245. 

  245.                             new TestingCommonToken(LITERAL_def, "def"),

    246. 

  246.                             new TestingCommonToken(FUNCTION, "log_src"),

    247. 

  247.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    248. 

  248.                             new TestingCommonToken(FUNCTION, "src"),

    249. 

  249.                             new TestingCommonToken(RPAREN, ")"),

    250. 

  250.                             new TestingCommonToken(LINE_BREAK, "\n"),

    251. 

  251.                             new TestingCommonToken(CONSTANT, "Logging", 2),

    252. 

  252.                             new TestingCommonToken(COLON2, "::", 2),

    253. 

  253.                             new TestingCommonToken(FUNCTION, "puts", 2),

    254. 

  254.                             new TestingCommonToken(HERE_DOC_BEGIN, "EOM", 2),

    255. 

  255.                             new TestingCommonToken(HERE_DOC_CONTENT, "checked program was:\n/* begin */\n%s/* end */\n\n", 2),

    256. 

  256.                             new TestingCommonToken(COMMA, ",", 7),

    257. 

  257.                             new TestingCommonToken(FUNCTION, "src", 7),

    258. 

  258.                             new TestingCommonToken(LINE_BREAK, "\n", 7),

    259. 

  259.                             new TestingCommonToken(LITERAL_end, "end", 8),

    260. 

  260.         };

    261. 

  261. 

    262. 

  262.         assert_type(program_text, token_types);

    263. 

  263.     }

    264. 

  264. 

    265. 

  265.     public void test_token_stream12() {

    266. 

  266.         String program_text = "1%200";

    267. 

  267. 

    268. 

  268.         TestingCommonToken[] token_types =  {

    269. 

  269.                             new TestingCommonToken(INTEGER, "1"),

    270. 

  270.                             new TestingCommonToken(MOD, "%"),

    271. 

  271.                             new TestingCommonToken(INTEGER, "200"),

    272. 

  272.         };

    273. 

  273. 

    274. 

  274.         assert_type(program_text, token_types);

    275. 

  275.     }

    276. 

  276. 

    277. 

  277.     public void test_token_stream13() {

    278. 

  278.         String program_text = "; ;\t   ;";

    279. 

  279. 

    280. 

  280.         TestingCommonToken[] token_types =  {

    281. 

  281.                             new TestingCommonToken(SEMI, ";"),

    282. 

  282.         };

    283. 

  283. 

    284. 

  284.         assert_type(program_text, token_types);

    285. 

  285.     }

    286. 

  286. 

    287. 

  287.     public void test_token_stream14() {

    288. 

  288.         String program_text = "a =1;a\n\n\n;;;;";

    289. 

  289. 

    290. 

  290.         TestingCommonToken[] token_types =  {

    291. 

  291.                             new TestingCommonToken(IDENTIFIER, "a"),

    292. 

  292.                             new TestingCommonToken(ASSIGN, "="),

    293. 

  293.                             new TestingCommonToken(INTEGER, "1"),

    294. 

  294.                             new TestingCommonToken(SEMI, ";"),

    295. 

  295.                             new TestingCommonToken(IDENTIFIER, "a"),

    296. 

  296.                             //new TestingCommonToken(LINE_BREAK, "\n"),

    297. 

  297.                             new TestingCommonToken(LINE_BREAK, "\n", 1),

    298. 

  298.         };

    299. 

  299. 

    300. 

  300.         assert_type(program_text, token_types);

    301. 

  301.     }

    302. 

  302. 

    303. 

  303.     public void test_token_stream15() {

    304. 

  304.         String program_text = "@numerator.to_f/@denominator.to_f";

    305. 

  305. 

    306. 

  306.         TestingCommonToken[] token_types =  {

    307. 

  307.                             new TestingCommonToken(INSTANCE_VARIABLE, "@numerator"),

    308. 

  308.                             new TestingCommonToken(DOT, "."),

    309. 

  309.                             new TestingCommonToken(FUNCTION, "to_f"),

    310. 

  310.                             new TestingCommonToken(DIV, "/"),

    311. 

  311.                             new TestingCommonToken(INSTANCE_VARIABLE, "@denominator"),

    312. 

  312.                             new TestingCommonToken(DOT, "."),

    313. 

  313.                             new TestingCommonToken(FUNCTION, "to_f"),

    314. 

  314.         };

    315. 

  315. 

    316. 

  316.         assert_type(program_text, token_types);

    317. 

  317.     }

    318. 

  318. 

    319. 

  319.     public void test_token_stream16() {

    320. 

  320.         String program_text = "sprintf(\"Rational(%s, %s)\", @numerator.inspect, @denominator.inspect)";

    321. 

  321. 

    322. 

  322.         TestingCommonToken[] token_types =  {

    323. 

  323.                             new TestingCommonToken(FUNCTION, "sprintf"),

    324. 

  324.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    325. 

  325.                             new TestingCommonToken(DOUBLE_QUOTE_STRING, "Rational(%s, %s)"),

    326. 

  326.                             new TestingCommonToken(COMMA, ","),

    327. 

  327.                             new TestingCommonToken(INSTANCE_VARIABLE, "@numerator"),

    328. 

  328.                             new TestingCommonToken(DOT, "."),

    329. 

  329.                             new TestingCommonToken(FUNCTION, "inspect"),

    330. 

  330.                             new TestingCommonToken(COMMA, ","),

    331. 

  331.                             new TestingCommonToken(INSTANCE_VARIABLE, "@denominator"),

    332. 

  332.                             new TestingCommonToken(DOT, "."),

    333. 

  333.                             new TestingCommonToken(FUNCTION, "inspect"),

    334. 

  334.                             new TestingCommonToken(RPAREN, ")"),

    335. 

  335.         };

    336. 

  336. 

    337. 

  337.         assert_type(program_text, token_types);

    338. 

  338.     }

    339. 

  339. 

    340. 

  340.     public void test_token_stream17() {

    341. 

  341.         String program_text = "subj.gsub! /\\n/, \"\"\n";

    342. 

  342. 

    343. 

  343.         TestingCommonToken[] token_types =  {

    344. 

  344.                             new TestingCommonToken(FUNCTION, "subj"),

    345. 

  345.                             new TestingCommonToken(DOT, "."),

    346. 

  346.                             new TestingCommonToken(FUNCTION, "gsub!"),

    347. 

  347.                             new TestingCommonToken(REGEX, "\\n/"),

    348. 

  348.                             new TestingCommonToken(COMMA, ","),

    349. 

  349.                             new TestingCommonToken(DOUBLE_QUOTE_STRING, ""),

    350. 

  350.                             new TestingCommonToken(LINE_BREAK, "\n"),

    351. 

  351.         };

    352. 

  352. 

    353. 

  353.         assert_type(program_text, token_types);

    354. 

  354.     }

    355. 

  355. 

    356. 

  356.     public void test_token_stream18() {

    357. 

  357.         String program_text = "self / Rational.new!(a, 1)";

    358. 

  358. 

    359. 

  359.         TestingCommonToken[] token_types =  {

    360. 

  360.                             new TestingCommonToken(LITERAL_self, "self"),

    361. 

  361.                             new TestingCommonToken(DIV, "/"),

    362. 

  362.                             new TestingCommonToken(CONSTANT, "Rational"),

    363. 

  363.                             new TestingCommonToken(DOT, "."),

    364. 

  364.                             new TestingCommonToken(FUNCTION, "new!"),

    365. 

  365.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    366. 

  366.                             new TestingCommonToken(IDENTIFIER, "a"),

    367. 

  367.                             new TestingCommonToken(COMMA, ","),

    368. 

  368.                             new TestingCommonToken(INTEGER, "1"),

    369. 

  369.                             new TestingCommonToken(RPAREN, ")"),

    370. 

  370.         };

    371. 

  371. 

    372. 

  372.         assert_type(program_text, token_types);

    373. 

  373.     }

    374. 

  374. 

    375. 

  375.     public void test_token_stream19() {

    376. 

  376.         String program_text = "session['key'].class";

    377. 

  377. 

    378. 

  378.         TestingCommonToken[] token_types =  {

    379. 

  379.                             new TestingCommonToken(FUNCTION, "session"),

    380. 

  380.                             new TestingCommonToken(LBRACK_ARRAY_ACCESS, "["),

    381. 

  381.                             new TestingCommonToken(SINGLE_QUOTE_STRING, "key"),

    382. 

  382.                             new TestingCommonToken(RBRACK, "]"),

    383. 

  383.                             new TestingCommonToken(DOT, "."),

    384. 

  384.                             new TestingCommonToken(IDENTIFIER, "class"),

    385. 

  385.         };

    386. 

  386. 

    387. 

  387.         assert_type(program_text, token_types);

    388. 

  388.     }

    389. 

  389. 

    390. 

  390.     public void test_token_stream20() {

    391. 

  391.         String program_text = "$4.to_i.to_r / (10**$4.size)";

    392. 

  392. 

    393. 

  393.         TestingCommonToken[] token_types =  {

    394. 

  394.                             new TestingCommonToken(GLOBAL_VARIABLE , "$4"),

    395. 

  395.                             new TestingCommonToken(DOT, "."),

    396. 

  396.                             new TestingCommonToken(FUNCTION, "to_i"),

    397. 

  397.                             new TestingCommonToken(DOT, "."),

    398. 

  398.                             new TestingCommonToken(FUNCTION, "to_r"),

    399. 

  399.                             new TestingCommonToken(DIV, "/"),

    400. 

  400.                             new TestingCommonToken(LPAREN, "("),

    401. 

  401.                             new TestingCommonToken(INTEGER, "10"),

    402. 

  402.                             new TestingCommonToken(POWER, "**"),

    403. 

  403.                             new TestingCommonToken(GLOBAL_VARIABLE , "$4"),

    404. 

  404.                             new TestingCommonToken(DOT, "."),

    405. 

  405.                             new TestingCommonToken(FUNCTION, "size"),

    406. 

  406.                             new TestingCommonToken(RPAREN, ")"),

    407. 

  407.         };

    408. 

  408. 

    409. 

  409.         assert_type(program_text, token_types);

    410. 

  410.     }

    411. 

  411. 

    412. 

  412.     public void test_token_stream21() {

    413. 

  413.         String program_text = "def check_response_auth( res )\n" +

    414. 

  414. "raise POPAuthenticationError, res unless /\\A\\+OK/i === res\n" +

    415. 

  415. "res\n" +

    416. 

  416. "end";

    417. 

  417. 

    418. 

  418.         TestingCommonToken[] token_types =  {

    419. 

  419.                             new TestingCommonToken(LITERAL_def, "def"),

    420. 

  420.                             new TestingCommonToken(FUNCTION, "check_response_auth"),

    421. 

  421.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    422. 

  422.                             new TestingCommonToken(FUNCTION, "res"),

    423. 

  423.                             new TestingCommonToken(RPAREN, ")"),

    424. 

  424.                             new TestingCommonToken(LINE_BREAK, "\n"),

    425. 

  425.                             new TestingCommonToken(FUNCTION, "raise", 2),

    426. 

  426.                             new TestingCommonToken(CONSTANT, "POPAuthenticationError", 2),

    427. 

  427.                             new TestingCommonToken(COMMA, ",", 2),

    428. 

  428.                             new TestingCommonToken(FUNCTION, "res", 2),

    429. 

  429.                             new TestingCommonToken(UNLESS_MODIFIER, "unless", 2),

    430. 

  430.                             new TestingCommonToken(REGEX, "\\A\\+OK/i", 2),

    431. 

  431.                             new TestingCommonToken(CASE_EQUAL, "===", 2),

    432. 

  432.                             new TestingCommonToken(FUNCTION, "res", 2),

    433. 

  433.                             new TestingCommonToken(LINE_BREAK, "\n", 2),

    434. 

  434.                             new TestingCommonToken(FUNCTION, "res", 3),

    435. 

  435.                             new TestingCommonToken(LINE_BREAK, "\n", 3),

    436. 

  436.                             new TestingCommonToken(LITERAL_end, "end", 4),

    437. 

  437.         };

    438. 

  438. 

    439. 

  439.         assert_type(program_text, token_types);

    440. 

  440.     }

    441. 

  441. 

    442. 

  442.     public void test_token_stream22() {

    443. 

  443.         String program_text = "res.split(/ /)[1]";

    444. 

  444. 

    445. 

  445.         TestingCommonToken[] token_types =  {

    446. 

  446.                             new TestingCommonToken(FUNCTION, "res"),

    447. 

  447.                             new TestingCommonToken(DOT, "."),

    448. 

  448.                             new TestingCommonToken(FUNCTION, "split"),

    449. 

  449.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    450. 

  450.                             new TestingCommonToken(REGEX, " /"),

    451. 

  451.                             new TestingCommonToken(RPAREN, ")"),

    452. 

  452.                             new TestingCommonToken(LBRACK_ARRAY_ACCESS, "["),

    453. 

  453.                             new TestingCommonToken(INTEGER, "1"),

    454. 

  454.                             new TestingCommonToken(RBRACK, "]"),

    455. 

  455.         };

    456. 

  456. 

    457. 

  457.         assert_type(program_text, token_types);

    458. 

  458.     }

    459. 

  459. 

    460. 

  460.     public void test_token_stream23() {

    461. 

  461.         String program_text = "f(*a)";

    462. 

  462. 

    463. 

  463.         TestingCommonToken[] token_types =  {

    464. 

  464.                             new TestingCommonToken(FUNCTION, "f"),

    465. 

  465.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "("),

    466. 

  466.                             new TestingCommonToken(REST_ARG_PREFIX, "*"),

    467. 

  467.                             new TestingCommonToken(FUNCTION, "a"),

    468. 

  468.                             new TestingCommonToken(RPAREN, ")"),

    469. 

  469.         };

    470. 

  470. 

    471. 

  471.         assert_type(program_text, token_types);

    472. 

  472.     }

    473. 

  473. 

    474. 

  474.     public void test_token_stream24() {

    475. 

  475.         String program_text = "puts puts = 1";

    476. 

  476. 

    477. 

  477.         TestingCommonToken[] token_types =  {

    478. 

  478.                             new TestingCommonToken(FUNCTION, "puts"),

    479. 

  479.                             new TestingCommonToken(IDENTIFIER, "puts"),

    480. 

  480.                             new TestingCommonToken(ASSIGN, "="),

    481. 

  481.                             new TestingCommonToken(INTEGER, "1"),

    482. 

  482.         };

    483. 

  483. 

    484. 

  484.         assert_type(program_text, token_types);

    485. 

  485.     }

    486. 

  486. 

    487. 

  487.     public void test_token_stream25() {

    488. 

  488.         String program_text = "def a; f do |element|\n"	+

    489. 

  489. "          klass.module_eval(<<-EOC, __FILE__, __LINE__)\n"	+

    490. 

  490. "          EOC\n"	+

    491. 

  491. "         end\n"	+

    492. 

  492. "     end";

    493. 

  493. 

    494. 

  494.         TestingCommonToken[] token_types =  {

    495. 

  495.                             new TestingCommonToken(LITERAL_def, "def"),

    496. 

  496.                             new TestingCommonToken(FUNCTION, "a"),

    497. 

  497.                             new TestingCommonToken(SEMI, ";"),

    498. 

  498.                             new TestingCommonToken(FUNCTION, "f"),

    499. 

  499.                             new TestingCommonToken(LITERAL_do, "do"),

    500. 

  500.                             new TestingCommonToken(BOR, "|"),

    501. 

  501.                             new TestingCommonToken(IDENTIFIER, "element"),

    502. 

  502.                             new TestingCommonToken(BOR, "|"),

    503. 

  503.                             new TestingCommonToken(LINE_BREAK, "\n"),

    504. 

  504.                             new TestingCommonToken(FUNCTION, "klass", 2),

    505. 

  505.                             new TestingCommonToken(DOT, ".", 2),

    506. 

  506.                             new TestingCommonToken(FUNCTION, "module_eval", 2),

    507. 

  507.                             new TestingCommonToken(LPAREN_WITH_NO_LEADING_SPACE, "(", 2),

    508. 

  508.                             new TestingCommonToken(HERE_DOC_BEGIN, "-EOC", 2),

    509. 

  509.                             new TestingCommonToken(HERE_DOC_CONTENT, "", 2),

    510. 

  510.                             new TestingCommonToken(COMMA, ",", 3),

    511. 

  511.                             new TestingCommonToken(LITERAL___FILE__, "__FILE__", 3),

    512. 

  512.                             new TestingCommonToken(COMMA, ",", 3),

    513. 

  513.                             new TestingCommonToken(LITERAL___LINE__, "__LINE__", 3),

    514. 

  514.                             new TestingCommonToken(RPAREN, ")", 3),

    515. 

  515.                             new TestingCommonToken(LINE_BREAK, "\n", 3),

    516. 

  516.                             new TestingCommonToken(LITERAL_end, "end", 4),

    517. 

  517.                             new TestingCommonToken(LINE_BREAK, "\n", 4),

    518. 

  518.                             new TestingCommonToken(LITERAL_end, "end", 5),

    519. 

  519.         };

    520. 

  520. 

    521. 

  521.         assert_type(program_text, token_types);

    522. 

  522.     }

    523. 

  523. 

    524. 

  524. 

    525. 

  525.     public void test_token_stream26() {

    526. 

  526.         String program_text = ";if true then end";

    527. 

  527. 

    528. 

  528.         TestingCommonToken[] token_types =  {

    529. 

  529.                             new TestingCommonToken(SEMI, ";"),

    530. 

  530.                             new TestingCommonToken(LITERAL_if, "if"),

    531. 

  531.                             new TestingCommonToken(LITERAL_true, "true"),

    532. 

  532.                             new TestingCommonToken(LITERAL_then, "then"),

    533. 

  533.                             new TestingCommonToken(LITERAL_end, "end"),

    534. 

  534.         };

    535. 

  535. 

    536. 

  536.         assert_type(program_text, token_types);

    537. 

  537.     }

    538. 

  538. 

    539. 

  539.     public void test_token_stream27() {

    540. 

  540.         String program_text = "module_eval <<-\"end_eval\"\n		end_eval\n";

    541. 

  541. 

    542. 

  542.         TestingCommonToken[] token_types =  {

    543. 

  543.                             new TestingCommonToken(FUNCTION, "module_eval"),

    544. 

  544.                             new TestingCommonToken(HERE_DOC_BEGIN, "-end_eval"),

    545. 

  545.                             new TestingCommonToken(HERE_DOC_CONTENT, ""),

    546. 

  546.                             new TestingCommonToken(LINE_BREAK, "\n", 2),

    547. 

  547.         };

    548. 

  548. 

    549. 

  549.         assert_type(program_text, token_types);

    550. 

  550.     }

    551. 

  551. 

    552. 

  552.     public void test_token_stream28() {

    553. 

  553.         String program_text = "1...3";

    554. 

  554. 

    555. 

  555.         TestingCommonToken[] token_types =  {

    556. 

  556.                             new TestingCommonToken(INTEGER, "1"),

    557. 

  557.                             new TestingCommonToken(EXCLUSIVE_RANGE, "..."),

    558. 

  558.                             new TestingCommonToken(INTEGER, "3"),

    559. 

  559.         };

    560. 

  560. 

    561. 

  561.         assert_type(program_text, token_types);

    562. 

  562.     }

    563. 

  563. 

    564. 

  564.     public void test_token_stream29() {

    565. 

  565.         String program_text = "puts 1 rescue true";

    566. 

  566. 

    567. 

  567.         TestingCommonToken[] token_types =  {

    568. 

  568.                             new TestingCommonToken(FUNCTION, "puts"),

    569. 

  569.                             new TestingCommonToken(INTEGER, "1"),

    570. 

  570.                             new TestingCommonToken(RESCUE_MODIFIER, "rescue"),

    571. 

  571.                             new TestingCommonToken(LITERAL_true, "true"),

    572. 

  572.         };

    573. 

  573. 

    574. 

  574.         assert_type(program_text, token_types);

    575. 

  575.     }

    576. 

  576. 

    577. 

  577.     public void test_token_stream30() {

    578. 

  578.         String program_text = "alias quo /";

    579. 

  579. 

    580. 

  580.         TestingCommonToken[] token_types =  {

    581. 

  581.                             new TestingCommonToken(LITERAL_alias, "alias"),

    582. 

  582.                             new TestingCommonToken(FUNCTION, "quo"),

    583. 

  583.                             new TestingCommonToken(DIV, "/"),

    584. 

  584.         };

    585. 

  585. 

    586. 

  586.         assert_type(program_text, token_types);

    587. 

  587.     }

    588. 

  588. 

    589. 

  589.     public void test_token_stream31() {

    590. 

  590.         String program_text = "print 1, <<EOF1, 2, <<EOF2, 3\n" +

    591. 

  591.         "EOF1\n" +

    592. 

  592.         "EOF2\n";

    593. 

  593. 

    594. 

  594.         TestingCommonToken[] token_types =  {

    595. 

  595.                             new TestingCommonToken(FUNCTION, "print"),

    596. 

  596.                             new TestingCommonToken(INTEGER, "1"),

    597. 

  597.                             new TestingCommonToken(COMMA, ","),

    598. 

  598.                             new TestingCommonToken(HERE_DOC_BEGIN, "EOF1"),

    599. 

  599.                             new TestingCommonToken(HERE_DOC_CONTENT, ""),

    600. 

  600.                             new TestingCommonToken(COMMA, ",", 2),

    601. 

  601.                             new TestingCommonToken(INTEGER, "2", 2),

    602. 

  602.                             new TestingCommonToken(COMMA, ",", 2),

    603. 

  603.                             new TestingCommonToken(HERE_DOC_BEGIN, "EOF2", 2),

    604. 

  604.                             new TestingCommonToken(HERE_DOC_CONTENT, "", 2),

    605. 

  605.                             new TestingCommonToken(COMMA, ",", 3),

    606. 

  606.                             new TestingCommonToken(INTEGER, "3", 3),

    607. 

  607.                             new TestingCommonToken(LINE_BREAK, "\n", 3),

    608. 

  608.         };

    609. 

  609. 

    610. 

  610.         assert_type(program_text, token_types);

    611. 

  611.     }

    612. 

  612. 

    613. 

  613.     /*need parser

    614. 

  614.     public void test_token_stream32() {

    615. 

  615.         String program_text = "print <<-EOF + \"#{'yyy'}\"\n" +

    616. 

  616.                             "  hey\n" +

    617. 

  617.                             " EOF\n";

    618. 

  618. 

    619. 

  619.         TestingCommonToken[] token_types =  {

    620. 

  620.                             new TestingCommonToken(FUNCTION, "print"),

    621. 

  621.                             new TestingCommonToken(HERE_DOC_BEGIN, "-EOF"),

    622. 

  622.                             new TestingCommonToken(HERE_DOC_CONTENT, "  hey\n"),

    623. 

  623.                             new TestingCommonToken(PLUS, "+", 3),

    624. 

  624.                             new TestingCommonToken(STRING_BEFORE_EXPRESSION_SUBSTITUTION, "", 3),

    625. 

  625.                             new TestingCommonToken(LCURLY_BLOCK, "{", 3),

    626. 

  626.                             new TestingCommonToken(SINGLE_QUOTE_STRING, "yyy", 3),

    627. 

  627.                             new TestingCommonToken(RCURLY, "}", 3),

    628. 

  628.                             new TestingCommonToken(STRING_BEFORE_EXPRESSION_SUBSTITUTION, "", 3),

    629. 

  629.                             new TestingCommonToken(LINE_BREAK, "\n", 3),

    630. 

  630.         };

    631. 

  631. 

    632. 

  632.         assert_type(program_text, token_types);

    633. 

  633.     }*/

    634. 

  634. 

    635. 

  635.     /*

    636. 

  636.     public void test_defined_question_mark() {

    637. 

  637.         String program_text = "defined?";

    638. 

  638.         assert_type(program_text, 89);

    639. 

  639.     }

    640. 

  640.     */

    641. 

  641. 

    642. 

  642.     public void test_EmptyString() {

    643. 

  643.         String program_text = "";

    644. 

  644.         assert_type(program_text, Token.EOF_TYPE, null);

    645. 

  645.     }

    646. 

  646. 

    647. 

  647.     public void test_REGEX() {

    648. 

  648.         String[] program_texts = {

    649. 

  649.             "/\\r\\n\\r\\n/s",

    650. 

  650.             "/^#/",

    651. 

  651.             "/^Ruby the OOPL/",

    652. 

  652.             "/ruby/i",

    653. 

  653.             "/test|test/x",

    654. 

  654.             "/([\\300-\\367])/n",

    655. 

  655.         };

    656. 

  656. 

    657. 

  657.         String[] expected_texts = {

    658. 

  658.             "\\r\\n\\r\\n/s",

    659. 

  659.             "^#/",

    660. 

  660.             "^Ruby the OOPL/",

    661. 

  661.             "ruby/i",

    662. 

  662.             "test|test/x",

    663. 

  663.             "([\\300-\\367])/n",

    664. 

  664.         };

    665. 

  665. 

    666. 

  666.         assert_type(program_texts, REGEX, expected_texts);

    667. 

  667.     }

    668. 

  668. 

    669. 

  669.     public void test_R_REGEX() {

    670. 

  670.         String[] program_texts = {

    671. 

  671.             "%r{([^ \\t\\r\\n\\[\\{\\(])\\'}",

    672. 

  672.             "%r{test|test}",

    673. 

  673.             "%r/^Ruby the OOPL/",

    674. 

  674.             "%r|ruby|i",

    675. 

  675.             "%r/test|test/x",

    676. 

  676.             "%r{test|test}x",

    677. 

  677.             "%r(test|test)x",

    678. 

  678.             "%r[test|test]x",

    679. 

  679.             "%r(<b>(.*?)</b>)",

    680. 

  680.             "%r{}",

    681. 

  681.         };

    682. 

  682. 

    683. 

  683.         String[] expected_texts = {

    684. 

  684.             "([^ \\t\\r\\n\\[\\{\\(])\\'/",

    685. 

  685.             "test|test/",

    686. 

  686.             "^Ruby the OOPL/",

    687. 

  687.             "ruby/i",

    688. 

  688.             "test|test/x",

    689. 

  689.             "test|test/x",

    690. 

  690.             "test|test/x",

    691. 

  691.             "test|test/x",

    692. 

  692.             "<b>(.*?)</b>/",

    693. 

  693.             "/",

    694. 

  694.         };

    695. 

  695. 

    696. 

  696.         assert_type(program_texts, REGEX, expected_texts);

    697. 

  697.     }

    698. 

  698.     /*

    699. 

  699.     public void test_SINGLE_QUOTA() {

    700. 

  700.         String program_text = "`";

    701. 

  701.         assert_type(program_text, SINGLE_QUOTA);

    702. 

  702.     }*/

    703. 

  703. 

    704. 

  704.     public void test_QUESTION() {

    705. 

  705.         String program_text = "?";

    706. 

  706.         assert_type(program_text, QUESTION);

    707. 

  707.     }

    708. 

  708. 

    709. 

  709.     public void test_LPAREN() {

    710. 

  710.         String program_text = "(";

    711. 

  711.         assert_type(program_text, LPAREN);

    712. 

  712.     }

    713. 

  713. 

    714. 

  714.     public void test_RPAREN() {

    715. 

  715.         String program_text = ")";

    716. 

  716.         assert_type(program_text, RPAREN);

    717. 

  717.     }

    718. 

  718. 

    719. 

  719.     public void test_LBRACK() {

    720. 

  720.         String program_text = "[";

    721. 

  721.         assert_type(program_text, LBRACK);

    722. 

  722.     }

    723. 

  723. 

    724. 

  724.     public void test_RBRACK() {

    725. 

  725.         String program_text = "]";

    726. 

  726.         assert_type(program_text, RBRACK);

    727. 

  727.     }

    728. 

  728. 

    729. 

  729.     public void test_LCURLY() {

    730. 

  730.         String program_text = "{";

    731. 

  731.         assert_type(program_text, LCURLY_HASH);

    732. 

  732.     }

    733. 

  733. 

    734. 

  734.     public void test_RCURLY() {

    735. 

  735.         String program_text = "}";

    736. 

  736.         assert_type(program_text, RCURLY);

    737. 

  737.     }

    738. 

  738. 

    739. 

  739.     public void test_COLON() {

    740. 

  740.         String program_text = ":";

    741. 

  741.         assert_type(program_text, COLON_WITH_NO_FOLLOWING_SPACE);

    742. 

  742.     }

    743. 

  743. 

    744. 

  744.     public void test_COMMA() {

    745. 

  745.         String[] program_texts = {

    746. 

  746.             ",",

    747. 

  747.             ", ",

    748. 

  748.             ",\n",

    749. 

  749.             ",   \n\n     \n",

    750. 

  750.         };

    751. 

  751. 

    752. 

  752.         String[] expected_texts = {

    753. 

  753.             ",",

    754. 

  754.             ",",

    755. 

  755.             ",",

    756. 

  756.             ",",

    757. 

  757.         };

    758. 

  758. 

    759. 

  759.         assert_type(program_texts, COMMA, expected_texts);

    760. 

  760.     }

    761. 

  761. 

    762. 

  762.     public void test_ASSIGN() {

    763. 

  763.         String program_text = "=";

    764. 

  764.         assert_type(program_text, ASSIGN);

    765. 

  765.     }

    766. 

  766. 

    767. 

  767.     public void test_PLUS_ASSIGN() {

    768. 

  768.         String program_text = "+=";

    769. 

  769.         assert_type(program_text, PLUS_ASSIGN);

    770. 

  770.     }

    771. 

  771. 

    772. 

  772.     public void test_MINUS_ASSIGN() {

    773. 

  773.         String program_text = "-=";

    774. 

  774.         assert_type(program_text, MINUS_ASSIGN);

    775. 

  775.     }

    776. 

  776. 

    777. 

  777.     public void test_STAR_ASSIGN() {

    778. 

  778.         String program_text = "*=";

    779. 

  779.         assert_type(program_text, STAR_ASSIGN);

    780. 

  780.     }

    781. 

  781. 

    782. 

  782.     /*

    783. 

  783.     public void test_DIV_ASSIGN() {

    784. 

  784.         String program_text = "/=";

    785. 

  785.         assert_type(program_text, DIV_ASSIGN);

    786. 

  786.     }

    787. 

  787.     */

    788. 

  788. 

    789. 

  789.     public void test_MOD_ASSIGN() {

    790. 

  790.         String program_text = "%=";

    791. 

  791.         assert_type(program_text, MOD_ASSIGN);

    792. 

  792.     }

    793. 

  793. 

    794. 

  794.     public void test_POWER_ASSIGN() {

    795. 

  795.         String program_text = "**=";

    796. 

  796.         assert_type(program_text, POWER_ASSIGN);

    797. 

  797.     }

    798. 

  798. 

    799. 

  799.     public void test_BAND_ASSIGN() {

    800. 

  800.         String program_text = "&=";

    801. 

  801.         assert_type(program_text, BAND_ASSIGN);

    802. 

  802.     }

    803. 

  803. 

    804. 

  804.     public void test_BXOR_ASSIGNN() {

    805. 

  805.         String program_text = "^=";

    806. 

  806.         assert_type(program_text, BXOR_ASSIGN);

    807. 

  807.     }

    808. 

  808. 

    809. 

  809.     public void test_BOR_ASSIGNN() {

    810. 

  810.         String program_text = "|=";

    811. 

  811.         assert_type(program_text, BOR_ASSIGN);

    812. 

  812.     }

    813. 

  813. 

    814. 

  814.     /*

    815. 

  815.     public void test_LEFT_SHIFT_ASSIGN() {

    816. 

  816.         String program_text = "<<=";

    817. 

  817.         assert_type(program_text, LEFT_SHIFT_ASSIGN);

    818. 

  818.     }

    819. 

  819.     */

    820. 

  820. 

    821. 

  821.     public void test_RIGHT_SHIFT_ASSIGN() {

    822. 

  822.         String program_text = ">>=";

    823. 

  823.         assert_type(program_text, RIGHT_SHIFT_ASSIGN);

    824. 

  824.     }

    825. 

  825. 

    826. 

  826.     public void test_LOGICAL_AND_ASSIGN() {

    827. 

  827.         String program_text = "&&=";

    828. 

  828.         assert_type(program_text, LOGICAL_AND_ASSIGN);

    829. 

  829.     }

    830. 

  830. 

    831. 

  831.     public void test_LOGICAL_OR_ASSIGN() {

    832. 

  832.         String program_text = "||=";

    833. 

  833.         assert_type(program_text, LOGICAL_OR_ASSIGN);

    834. 

  834.     }

    835. 

  835. 

    836. 

  836.     public void test_NOT() {

    837. 

  837.         String program_text = "!";

    838. 

  838.         assert_type(program_text, NOT);

    839. 

  839.     }

    840. 

  840. 

    841. 

  841.     public void test_BNOT() {

    842. 

  842.         String program_text = "~";

    843. 

  843.         assert_type(program_text, BNOT);

    844. 

  844.     }

    845. 

  845. 

    846. 

  846.     public void test_DIV() {

    847. 

  847.         String program_text = "/";

    848. 

  848.         assert_type(program_text, DIV);

    849. 

  849.     }

    850. 

  850. 

    851. 

  851.     public void test_PLUS() {

    852. 

  852.         String program_text = "+";

    853. 

  853.         assert_type(program_text, UNARY_PLUS);

    854. 

  854.     }

    855. 

  855. 

    856. 

  856.     /*

    857. 

  857.     public void test_MOD() {

    858. 

  858.         String program_text = "%";

    859. 

  859.         assert_type(program_text, MOD);

    860. 

  860.     }

    861. 

  861.     */

    862. 

  862. 

    863. 

  863.     public void test_MINUS() {

    864. 

  864.         String program_text = "-";

    865. 

  865.         assert_type(program_text, UNARY_MINUS);

    866. 

  866.     }

    867. 

  867. 

    868. 

  868.     public void test_STAR() {

    869. 

  869.         String program_text = "*";

    870. 

  870.         assert_type(program_text, REST_ARG_PREFIX);

    871. 

  871.     }

    872. 

  872. 

    873. 

  873.     public void test_LESS_THAN() {

    874. 

  874.         String program_text = "<";

    875. 

  875.         assert_type(program_text, LESS_THAN);

    876. 

  876.     }

    877. 

  877. 

    878. 

  878.     public void test_GREATER_THAN() {

    879. 

  879.         String program_text = ">";

    880. 

  880.         assert_type(program_text, GREATER_THAN);

    881. 

  881.     }

    882. 

  882. 

    883. 

  883.     public void test_BXOR() {

    884. 

  884.         String program_text = "^";

    885. 

  885.         assert_type(program_text, BXOR);

    886. 

  886.     }

    887. 

  887. 

    888. 

  888.     public void test_BOR() {

    889. 

  889.         String program_text = "|";

    890. 

  890.         assert_type(program_text, BOR);

    891. 

  891.     }

    892. 

  892. 

    893. 

  893.     public void test_LOGICAL_OR() {

    894. 

  894.         String program_text = "||";

    895. 

  895.         assert_type(program_text, LOGICAL_OR);

    896. 

  896.     }

    897. 

  897. 

    898. 

  898.     public void test_LOGICAL_AND() {

    899. 

  899.         String program_text = "&&";

    900. 

  900.         assert_type(program_text, LOGICAL_AND);

    901. 

  901.     }

    902. 

  902. 

    903. 

  903.     public void test_BAND() {

    904. 

  904.         String program_text = "&";

    905. 

  905.         assert_type(program_text, BLOCK_ARG_PREFIX);

    906. 

  906.     }

    907. 

  907. 

    908. 

  908.     public void test_SEMI() {

    909. 

  909.         String[] program_texts = {

    910. 

  910.             ";",

    911. 

  911.             ";;;",

    912. 

  912.         };

    913. 

  913. 

    914. 

  914.         String[] expected_texts = {

    915. 

  915.             ";",

    916. 

  916.             ";",

    917. 

  917.         };

    918. 

  918. 

    919. 

  919.         assert_type(program_texts, SEMI, expected_texts);

    920. 

  920.     }

    921. 

  921. 

    922. 

  922.     public void test_SEMI_as_LINEBREAK() {

    923. 

  923.         String[] program_texts = {

    924. 

  924.             "\n  \n\t\n\n;\n;",

    925. 

  925.             ";\n\n\n",

    926. 

  926.             ";;  ;;\n;;\n\n;;",

    927. 

  927.         };

    928. 

  928. 

    929. 

  929.         String[] expected_texts = {

    930. 

  930.             "\n",

    931. 

  931.             ";",

    932. 

  932.             ";",

    933. 

  933.         };

    934. 

  934. 

    935. 

  935.         assert_type(program_texts, LINE_BREAK, expected_texts);

    936. 

  936.     }

    937. 

  937. 

    938. 

  938.     public void test_ASSOC() {

    939. 

  939.         String program_text = "=>";

    940. 

  940.         assert_type(program_text, ASSOC);

    941. 

  941.     }

    942. 

  942. 

    943. 

  943.     public void test_INCLUSIVE_RANGE() {

    944. 

  944.         String program_text = "..";

    945. 

  945.         assert_type(program_text, INCLUSIVE_RANGE);

    946. 

  946.     }

    947. 

  947. 

    948. 

  948.     public void test_EXCLUSIVE_RANGE() {

    949. 

  949.         String program_text = "...";

    950. 

  950.         assert_type(program_text, EXCLUSIVE_RANGE);

    951. 

  951.     }

    952. 

  952. 

    953. 

  953.     public void test_POWER() {

    954. 

  954.         String program_text = "**";

    955. 

  955.         assert_type(program_text, POWER);

    956. 

  956.     }

    957. 

  957. 

    958. 

  958.     public void test_COMPARE() {

    959. 

  959.         String program_text = "<=>";

    960. 

  960.         assert_type(program_text, COMPARE);

    961. 

  961.     }

    962. 

  962. 

    963. 

  963.     public void test_GREATER_OR_EQUAL() {

    964. 

  964.         String program_text = ">=";

    965. 

  965.         assert_type(program_text, GREATER_OR_EQUAL);

    966. 

  966.     }

    967. 

  967. 

    968. 

  968.     public void test_LESS_OR_EQUAL() {

    969. 

  969.         String program_text = "<=";

    970. 

  970.         assert_type(program_text, LESS_OR_EQUAL);

    971. 

  971.     }

    972. 

  972. 

    973. 

  973.     public void test_EQUAL() {

    974. 

  974.         String program_text = "==";

    975. 

  975.         assert_type(program_text, EQUAL);

    976. 

  976.     }

    977. 

  977. 

    978. 

  978.     public void test_CASE_EQUAL() {

    979. 

  979.         String program_text = "===";

    980. 

  980.         assert_type(program_text, CASE_EQUAL);

    981. 

  981.     }

    982. 

  982. 

    983. 

  983.     public void test_NOT_EQUAL() {

    984. 

  984.         String program_text = "!=";

    985. 

  985.         assert_type(program_text, NOT_EQUAL);

    986. 

  986.     }

    987. 

  987. 

    988. 

  988.     public void test_MATCH() {

    989. 

  989.         String program_text = "=~";

    990. 

  990.         assert_type(program_text, MATCH);

    991. 

  991.     }

    992. 

  992. 

    993. 

  993.     public void test_NOT_MATCH() {

    994. 

  994.         String program_text = "!~";

    995. 

  995.         assert_type(program_text, NOT_MATCH);

    996. 

  996.     }

    997. 

  997. 

    998. 

  998.     public void test_LEFT_SHIFT() {

    999. 

  999.         String program_text = "<<";

    1000. 

  1000.         assert_type(program_text, LEFT_SHIFT);

    1001. 

  1001.     }

    1002. 

  1002. 

    1003. 

  1003.     public void test_RIGHT_SHIFT() {

    1004. 

  1004.         String program_text = ">>";

    1005. 

  1005.         assert_type(program_text, RIGHT_SHIFT);

    1006. 

  1006.     }

    1007. 

  1007. 

    1008. 

  1008.     public void test_COLON2() {

    1009. 

  1009.         String program_text = "::";

    1010. 

  1010.         assert_type(program_text, LEADING_COLON2);

    1011. 

  1011.     }

    1012. 

  1012. 

    1013. 

  1013.     public void test_LINE_BREAK() {

    1014. 

  1014.         String[] program_texts = {

    1015. 

  1015.             "\r",

    1016. 

  1016.             "\n",

    1017. 

  1017.             "\r\n",

    1018. 

  1018.             "\n\n\n\n\n",

    1019. 

  1019.             "\r\n\n\r\n\n\n\r\n\r\n",

    1020. 

  1020.         };

    1021. 

  1021. 

    1022. 

  1022.         String[] expected_texts = {

    1023. 

  1023.             "",

    1024. 

  1024.             "\n",

    1025. 

  1025.             "\n",

    1026. 

  1026.             "\n",

    1027. 

  1027.             "\n",

    1028. 

  1028.         };

    1029. 

  1029. 

    1030. 

  1030.         assert_type(program_texts, LINE_BREAK, expected_texts);

    1031. 

  1031.     }

    1032. 

  1032. 

    1033. 

  1033.     public void test_FUNCTION() {

    1034. 

  1034.         String[] program_texts = {

    1035. 

  1035.             "puts",

    1036. 

  1036.             "print",

    1037. 

  1037.         };

    1038. 

  1038. 

    1039. 

  1039.         assert_type(program_texts, FUNCTION);

    1040. 

  1040.     }

    1041. 

  1041. 

    1042. 

  1042.     public void test_IDENTIFIER  () {

    1043. 

  1043.         String[] program_texts = {

    1044. 

  1044.             "hey",

    1045. 

  1045.             "_",

    1046. 

  1046.             "_1",

    1047. 

  1047.             "_a",

    1048. 

  1048.             "abc123",

    1049. 

  1049.             "_________aaaaaaa11111111111____________ZZZZZZZZZ00000000000",

    1050. 

  1050.             "_ab1",

    1051. 

  1051.         };

    1052. 

  1052. 

    1053. 

  1053.         assert_type(program_texts, FUNCTION);

    1054. 

  1054.     }

    1055. 

  1055. 

    1056. 

  1056.     public void test_PREDICATE_FUNCTION() {

    1057. 

  1057.         String[] program_texts = {

    1058. 

  1058.             "hey?",

    1059. 

  1059.             "_?",

    1060. 

  1060.             "_1?",

    1061. 

  1061.             "_a?",

    1062. 

  1062.             "_________aaaaaaa11111111111____________ZZZZZZZZZ00000000000?",

    1063. 

  1063.             "_2b2abC?",

    1064. 

  1064.         };

    1065. 

  1065. 

    1066. 

  1066.         assert_type(program_texts, FUNCTION);

    1067. 

  1067.     }

    1068. 

  1068. 

    1069. 

  1069.     public void test_DESTRUCTIVE_FUNCTION() {

    1070. 

  1070.         String[] program_texts = {

    1071. 

  1071.             "hey!",

    1072. 

  1072.             "_!",

    1073. 

  1073.             "_1!",

    1074. 

  1074.             "_a!",

    1075. 

  1075.             "_________aaaaaaa11111111111____________ZZZZZZZZZ00000000000!",

    1076. 

  1076.             "_1abC!",

    1077. 

  1077.         };

    1078. 

  1078. 

    1079. 

  1079.         assert_type(program_texts, FUNCTION);

    1080. 

  1080.     }

    1081. 

  1081. 

    1082. 

  1082.     public void test_GLOBAL_VARIABLE () {

    1083. 

  1083.         String[] program_texts = {

    1084. 

  1084.             "$-#",

    1085. 

  1085.             "$-",

    1086. 

  1086.             "$-K",

    1087. 

  1087.             "$A",

    1088. 

  1088.             "$a",

    1089. 

  1089.             "$aBC12_",

    1090. 

  1090.             "$_",

    1091. 

  1091.             "$__",

    1092. 

  1092.             "$a234",

    1093. 

  1093. 

    1094. 

  1094.             "$&",

    1095. 

  1095.             "$`",

    1096. 

  1096.             "$\\",

    1097. 

  1097.             "$+",

    1098. 

  1098. 

    1099. 

  1099.             "$1",

    1100. 

  1100.             "$2",

    1101. 

  1101.             "$3",

    1102. 

  1102.             "$4",

    1103. 

  1103.             "$5",

    1104. 

  1104.             "$6",

    1105. 

  1105.             "$7",

    1106. 

  1106.             "$8",

    1107. 

  1107.             "$9",

    1108. 

  1108.             "$123456",

    1109. 

  1109.         };

    1110. 

  1110. 

    1111. 

  1111.         assert_type(program_texts, GLOBAL_VARIABLE );

    1112. 

  1112.     }

    1113. 

  1113. 

    1114. 

  1114.     public void test_INSTANCE_VARIABLE() {

    1115. 

  1115.         String[] program_texts = {

    1116. 

  1116.             "@A",

    1117. 

  1117.             "@a",

    1118. 

  1118.             "@aBC12_",

    1119. 

  1119.             "@_",

    1120. 

  1120.         };

    1121. 

  1121. 

    1122. 

  1122.         assert_type(program_texts, INSTANCE_VARIABLE);

    1123. 

  1123.     }

    1124. 

  1124. 

    1125. 

  1125.     public void test_CLASS_VARIABLE() {

    1126. 

  1126.         String[] program_texts = {

    1127. 

  1127.             "@@A",

    1128. 

  1128.             "@@a",

    1129. 

  1129.             "@@aBC12_",

    1130. 

  1130.             "@@_",

    1131. 

  1131.         };

    1132. 

  1132. 

    1133. 

  1133.         assert_type(program_texts, CLASS_VARIABLE);

    1134. 

  1134.     }

    1135. 

  1135. 

    1136. 

  1136.     public void test_CONSTANT() {

    1137. 

  1137.         String[] program_texts = {

    1138. 

  1138.             "A",

    1139. 

  1139.             "Z",

    1140. 

  1140.             "A_",

    1141. 

  1141.             "Abc",

    1142. 

  1142.             "B2",

    1143. 

  1143.             "PI",

    1144. 

  1144.             "MyClass3",

    1145. 

  1145.         };

    1146. 

  1146. 

    1147. 

  1147.         assert_type(program_texts, CONSTANT);

    1148. 

  1148.     }

    1149. 

  1149. 

    1150. 

  1150.     public void test_INTEGER() {

    1151. 

  1151.         String[] program_texts = {

    1152. 

  1152.             "123456",

    1153. 

  1153.             "1",

    1154. 

  1154.             "543",

    1155. 

  1155.             "0",

    1156. 

  1156.             "123_456",

    1157. 

  1157.             "123_456_789_123_345_789",

    1158. 

  1158.         };

    1159. 

  1159. 

    1160. 

  1160.         String[] expected_texts = {

    1161. 

  1161.             "123456",

    1162. 

  1162.             "1",

    1163. 

  1163.             "543",

    1164. 

  1164.             "0",

    1165. 

  1165.             "123456",

    1166. 

  1166.             "123456789123345789",

    1167. 

  1167.         };

    1168. 

  1168. 

    1169. 

  1169.         assert_type(program_texts, INTEGER, expected_texts);

    1170. 

  1170.     }

    1171. 

  1171. 

    1172. 

  1172.     public void test_HEX() {

    1173. 

  1173.         String[] program_texts = {

    1174. 

  1174.             "0xaabbC",

    1175. 

  1175.             "0X0abb1",

    1176. 

  1176.         };

    1177. 

  1177. 

    1178. 

  1178.         String[] expected_texts = {

    1179. 

  1179.             "aabbC",

    1180. 

  1180.             "0abb1",

    1181. 

  1181.         };

    1182. 

  1182. 

    1183. 

  1183.         assert_type(program_texts, HEX, expected_texts);

    1184. 

  1184.     }

    1185. 

  1185. 

    1186. 

  1186.     public void test_OCTAL() {

    1187. 

  1187.         String[] program_texts = {

    1188. 

  1188.             "0377",

    1189. 

  1189.         };

    1190. 

  1190. 

    1191. 

  1191.         String[] expected_texts = {

    1192. 

  1192.             "377",

    1193. 

  1193.         };

    1194. 

  1194. 

    1195. 

  1195.         assert_type(program_texts, OCTAL, expected_texts);

    1196. 

  1196.     }

    1197. 

  1197. 

    1198. 

  1198.     public void test_BINARY() {

    1199. 

  1199.         String[] program_texts = {

    1200. 

  1200.             "0b1010",

    1201. 

  1201.             "0B0100",

    1202. 

  1202.             "0b001_001",

    1203. 

  1203.         };

    1204. 

  1204. 

    1205. 

  1205.         String[] expected_texts = {

    1206. 

  1206.             "1010",

    1207. 

  1207.             "0100",

    1208. 

  1208.             "001001",

    1209. 

  1209.         };

    1210. 

  1210. 

    1211. 

  1211.         assert_type(program_texts, BINARY, expected_texts);

    1212. 

  1212.     }

    1213. 

  1213. 

    1214. 

  1214.     public void test_ASCII_VALUE() {

    1215. 

  1215.         String[] program_texts = {

    1216. 

  1216.                 "?&",

    1217. 

  1217.                 "?a",

    1218. 

  1218.                 "?\"",

    1219. 

  1219.                 "?\\n",

    1220. 

  1220.                 "?\\s",

    1221. 

  1221.                 "?\\C-a",

    1222. 

  1222.                 "?\\M-a",

    1223. 

  1223.                 "?\\M-\\C-a",

    1224. 

  1224.                 "?\\C-?",

    1225. 

  1225.             };

    1226. 

  1226. 

    1227. 

  1227.             assert_type(program_texts, ASCII_VALUE);

    1228. 

  1228.     }

    1229. 

  1229. 

    1230. 

  1230.     public void test_FLOAT() {

    1231. 

  1231.         String[] program_texts = {

    1232. 

  1232.             ".1",

    1233. 

  1233.             ".00",

    1234. 

  1234.             "12.34",

    1235. 

  1235.             "12.0",

    1236. 

  1236.             "0.2E2",

    1237. 

  1237.             ".1234E2",

    1238. 

  1238.             ".0234E+2",

    1239. 

  1239.             ".1234e-2",

    1240. 

  1240.             "1234e-2",

    1241. 

  1241.             "1234E-21",

    1242. 

  1242.             "0.0",

    1243. 

  1243.             "1e3",

    1244. 

  1244.             "2e18",

    1245. 

  1245.             "2E-18",

    1246. 

  1246.         };

    1247. 

  1247. 

    1248. 

  1248.         assert_type(program_texts, FLOAT);

    1249. 

  1249.     }

    1250. 

  1250. 

    1251. 

  1251.     public void test_DOT() {

    1252. 

  1252.         String program_texts = ".";

    1253. 

  1253. 

    1254. 

  1254.         assert_type(program_texts, DOT);

    1255. 

  1255.     }

    1256. 

  1256. 

    1257. 

  1257.     public void test_DOUBLE_QUOTE_STRING_LITERAL() {

    1258. 

  1258. 

    1259. 

  1259.         String[] program_texts = {

    1260. 

  1260.             "\"Rational(%s, %s)\"",

    1261. 

  1261.             "\"%Y-%m-%d %H:%M:%S\"",

    1262. 

  1262.             "\"\"",

    1263. 

  1263.             "\" \"",

    1264. 

  1264.             "\"string\"",

    1265. 

  1265.             "\"hello\"",

    1266. 

  1266.             "\" this is a string \"",

    1267. 

  1267.             "\"2\"",

    1268. 

  1268.             "\"\\\\\"",

    1269. 

  1269.             "\"\\n\"",

    1270. 

  1270.             "\"/usr/local\"",

    1271. 

  1271.             "\"\\360\"",

    1272. 

  1272.             "\"hello\n    world\"",

    1273. 

  1273.         };

    1274. 

  1274. 

    1275. 

  1275.         String[] expected_texts = {

    1276. 

  1276.             "Rational(%s, %s)",

    1277. 

  1277.             "%Y-%m-%d %H:%M:%S",

    1278. 

  1278.             "",

    1279. 

  1279.             " ",

    1280. 

  1280.             "string",

    1281. 

  1281.             "hello",

    1282. 

  1282.             " this is a string ",

    1283. 

  1283.             "2",

    1284. 

  1284.             "\\\\",

    1285. 

  1285.             "\\n",

    1286. 

  1286.             "/usr/local",

    1287. 

  1287.             "\\360",

    1288. 

  1288.             "hello\n    world",

    1289. 

  1289.         };

    1290. 

  1290. 

    1291. 

  1291.         assert_type(program_texts, DOUBLE_QUOTE_STRING, expected_texts);

    1292. 

  1292.     }

    1293. 

  1293. 

    1294. 

  1294.     public void test_COMMAND_OUTPUT() {

    1295. 

  1295. 

    1296. 

  1296.         String[] program_texts = {

    1297. 

  1297.             "``",

    1298. 

  1298.             "` `",

    1299. 

  1299.             "`command`",

    1300. 

  1300.             "` this is a command `",

    1301. 

  1301.             "`2`",

    1302. 

  1302.             "`\\\\`",

    1303. 

  1303.             "`\\n`",

    1304. 

  1304.         };

    1305. 

  1305. 

    1306. 

  1306.         String[] expected_texts = {

    1307. 

  1307.             "",

    1308. 

  1308.             " ",

    1309. 

  1309.             "command",

    1310. 

  1310.             " this is a command ",

    1311. 

  1311.             "2",

    1312. 

  1312.             "\\\\",

    1313. 

  1313.             "\\n",

    1314. 

  1314.         };

    1315. 

  1315. 

    1316. 

  1316.         assert_type(program_texts, COMMAND_OUTPUT, expected_texts);

    1317. 

  1317.     }

    1318. 

  1318. 

    1319. 

  1319.     public void test_X_COMMAND_OUTPUT() {

    1320. 

  1320.         String[] program_texts = {

    1321. 

  1321.             "%x/^Ruby the OOPL/",

    1322. 

  1322.             "%x|ruby|",

    1323. 

  1323.             "%x/test|test/",

    1324. 

  1324.             "%x{test|test}",

    1325. 

  1325.             "%x(test|test)",

    1326. 

  1326.             "%x[test|test]",

    1327. 

  1327.         };

    1328. 

  1328. 

    1329. 

  1329.         String[] expected_texts = {

    1330. 

  1330.             "^Ruby the OOPL",

    1331. 

  1331.             "ruby",

    1332. 

  1332.             "test|test",

    1333. 

  1333.             "test|test",

    1334. 

  1334.             "test|test",

    1335. 

  1335.             "test|test",

    1336. 

  1336.         };

    1337. 

  1337. 

    1338. 

  1338.         assert_type(program_texts, COMMAND_OUTPUT, expected_texts);

    1339. 

  1339.     }

    1340. 

  1340. 

    1341. 

  1341. 

    1342. 

  1342.     public void test_SINGLE_QUOTE_STRING_LITERAL() {

    1343. 

  1343. 

    1344. 

  1344.         String[] program_texts = {

    1345. 

  1345.             "\'\'",

    1346. 

  1346.             "\' \'",

    1347. 

  1347.             "\'string\'",

    1348. 

  1348.             "\' this is a #@string \'",

    1349. 

  1349.             "\'2\'",

    1350. 

  1350.             "\'\\\\\'",

    1351. 

  1351.             "\'\\n\'",

    1352. 

  1352.             "\'hello\n    #{world}\'",

    1353. 

  1353.         };

    1354. 

  1354. 

    1355. 

  1355.         String[] expected_texts = {

    1356. 

  1356.             "",

    1357. 

  1357.             " ",

    1358. 

  1358.             "string",

    1359. 

  1359.             " this is a #@string ",

    1360. 

  1360.             "2",

    1361. 

  1361.             "\\\\",

    1362. 

  1362.             "\\n",

    1363. 

  1363.             "hello\n    #{world}",

    1364. 

  1364.         };

    1365. 

  1365. 

    1366. 

  1366.         assert_type(program_texts, SINGLE_QUOTE_STRING, expected_texts);

    1367. 

  1367.     }

    1368. 

  1368. 

    1369. 

  1369.     public void test_q_STRING() {

    1370. 

  1370.         String[] program_texts = {

    1371. 

  1371.             "%q!test string!",

    1372. 

  1372.             "%q//",

    1373. 

  1373.             "%q# #",

    1374. 

  1374.             "%q$string$'",

    1375. 

  1375.             "%q^ this is a string ^",

    1376. 

  1376.         };

    1377. 

  1377. 

    1378. 

  1378.         String[] expected_texts = {

    1379. 

  1379.             "test string",

    1380. 

  1380.             "",

    1381. 

  1381.             " ",

    1382. 

  1382.             "string",

    1383. 

  1383.             " this is a string ",

    1384. 

  1384.         };

    1385. 

  1385. 

    1386. 

  1386.         assert_type(program_texts, SINGLE_QUOTE_STRING, expected_texts);

    1387. 

  1387.     }

    1388. 

  1388.     public void test_Q_STRING() {

    1389. 

  1389.         String[] program_texts = {

    1390. 

  1390.             "%/test string/",

    1391. 

  1391.             "%Q/test string/",

    1392. 

  1392.             "%Q\ntest string\n",

    1393. 

  1393.             "%Q*2*",

    1394. 

  1394.             "%Q(\\\\)",

    1395. 

  1395.             "%Q{\\\\}",

    1396. 

  1396.             "%Q[\\\\]",

    1397. 

  1397.             "%Q]\\\\]",

    1398. 

  1398.             "%Q}\\\\}",

    1399. 

  1399.             "%Q)\\\\)",

    1400. 

  1400.             "%Q!\\n!",

    1401. 

  1401.         };

    1402. 

  1402. 

    1403. 

  1403.         String[] expected_texts = {

    1404. 

  1404.             "test string",

    1405. 

  1405.             "test string",

    1406. 

  1406.             "test string",

    1407. 

  1407.             "2",

    1408. 

  1408.             "\\\\",

    1409. 

  1409.             "\\\\",

    1410. 

  1410.             "\\\\",

    1411. 

  1411.             "\\\\",

    1412. 

  1412.             "\\\\",

    1413. 

  1413.             "\\\\",

    1414. 

  1414.             "\\n",

    1415. 

  1415.         };

    1416. 

  1416. 

    1417. 

  1417.         assert_type(program_texts, DOUBLE_QUOTE_STRING, expected_texts);

    1418. 

  1418.     }

    1419. 

  1419. 

    1420. 

  1420.     public void test_COMMENT() {

    1421. 

  1421.         String[] program_texts = {

    1422. 

  1422.             "#",

    1423. 

  1423.             "# ",

    1424. 

  1424.             "#             ",

    1425. 

  1425.             "#12424scvdsfv",

    1426. 

  1426.             "#4r fgr rt",

    1427. 

  1427.             "#winClicker",

    1428. 

  1428.         };

    1429. 

  1429. 

    1430. 

  1430.         String[] expected_texts = {

    1431. 

  1431.             null,

    1432. 

  1432.             null,

    1433. 

  1433.             null,

    1434. 

  1434.             null,

    1435. 

  1435.             null,

    1436. 

  1436.             null,

    1437. 

  1437.         };

    1438. 

  1438. 

    1439. 

  1439.         assert_type(program_texts, Token.EOF_TYPE, expected_texts);

    1440. 

  1440.     }

    1441. 

  1441. 

    1442. 

  1442.     public void test_WHITE_SPACE() {

    1443. 

  1443.         String[] program_texts = {

    1444. 

  1444.             " ",

    1445. 

  1445.             "\t",

    1446. 

  1446.             "            ",

    1447. 

  1447.             "\t\t\t\t\t",

    1448. 

  1448.             " \t\t         \t",

    1449. 

  1449.         };

    1450. 

  1450. 

    1451. 

  1451.         String[] expected_texts = {

    1452. 

  1452.             null,

    1453. 

  1453.             null,

    1454. 

  1454.             null,

    1455. 

  1455.             null,

    1456. 

  1456.             null,

    1457. 

  1457.         };

    1458. 

  1458. 

    1459. 

  1459.         assert_type(program_texts, Token.EOF_TYPE, expected_texts);

    1460. 

  1460.     }

    1461. 

  1461. 

    1462. 

  1462.     public void test_LINE_CONTINUATION() {

    1463. 

  1463.         String[] program_texts = {

    1464. 

  1464.             "\\\n",

    1465. 

  1465.         };

    1466. 

  1466. 

    1467. 

  1467.         String[] expected_texts = {

    1468. 

  1468.             null,

    1469. 

  1469.         };

    1470. 

  1470. 

    1471. 

  1471.         assert_type(program_texts, Token.EOF_TYPE, expected_texts);

    1472. 

  1472.     }

    1473. 

  1473. 

    1474. 

  1474.     /*public void test_HERE_DOC_BEGIN() {

    1475. 

  1475.         String[] program_texts = {

    1476. 

  1476.             "<<EOF\nThe price is #{$Price}.\nEOF\n",

    1477. 

  1477.             "-<<123456\nThe\n price\n is #{$Price}.\n123456\n",

    1478. 

  1478.             "<<!@#$%^&*\nThe price is\n #{$Price}.\n!@#$%^&*\n",

    1479. 

  1479.         };

    1480. 

  1480. 

    1481. 

  1481.         String[] expected_texts = {

    1482. 

  1482.             "The price is #{$Price}.\n",

    1483. 

  1483.             "The\n price\n is #{$Price}.\n",

    1484. 

  1484.             "The price is\n #{$Price}.\n",

    1485. 

  1485.         };

    1486. 

  1486. 

    1487. 

  1487.         assert_type(program_texts, HERE_DOC_BEGIN, expected_texts);

    1488. 

  1488.     }*/

    1489. 

  1489. 

    1490. 

  1490.     public void test_RDOC() {

    1491. 

  1491.         String[] program_texts = {

    1492. 

  1492.             "=begin\n=end",

    1493. 

  1493.             "=begin\nwhatever\n=end",

    1494. 

  1494.             "=begin\nwha\n\n%^$%^$%$^&$%\n\n&tever\n=end",

    1495. 

  1495.         };

    1496. 

  1496. 

    1497. 

  1497.         String[] expected_texts = {

    1498. 

  1498.             null,

    1499. 

  1499.             null,

    1500. 

  1500.             null,

    1501. 

  1501.         };

    1502. 

  1502. 

    1503. 

  1503.         assert_type(program_texts, Token.EOF_TYPE, expected_texts);

    1504. 

  1504.     }

    1505. 

  1505. 

    1506. 

  1506.     public void test_W_ARRAY() {

    1507. 

  1507.         String[] program_texts = {

    1508. 

  1508.             "%w(folder openfold)",

    1509. 

  1509.             "%w/test string/",

    1510. 

  1510.             "%W!test string!",

    1511. 

  1511.             "%w\ntest string\n",

    1512. 

  1512.             "%W&Seconds/day: #{24*60*60}&",

    1513. 

  1513. 

    1514. 

  1514.             "%w//",

    1515. 

  1515.             "%w# #",

    1516. 

  1516.             "%w$string$'",

    1517. 

  1517.             "%W^ this is a string ^",

    1518. 

  1518.             "%W*2*",

    1519. 

  1519.             "%W(\\\\)",

    1520. 

  1520.             "%w{\\\\}",

    1521. 

  1521.             "%w[\\\\]",

    1522. 

  1522.             "%w]\\\\]",

    1523. 

  1523.             "%w}\\\\}",

    1524. 

  1524.             "%w)\\\\)",

    1525. 

  1525.             "%W!\\n!",

    1526. 

  1526.         };

    1527. 

  1527. 

    1528. 

  1528.         String[] expected_texts = {

    1529. 

  1529.             "folder openfold",

    1530. 

  1530.             "test string",

    1531. 

  1531.             "test string",

    1532. 

  1532.             "test string",…
    1533.

Large files files are truncated, but you can click here to view the full file