ruby_parser-1.0.0/test/test_ruby_lexer.rb

   1 #!/usr/local/bin/ruby
   2
   3 require 'test/unit'
   4 require 'ruby_lexer'
   5
   6 class TestRubyLexer < Test::Unit::TestCase
   7   def deny cond, msg = nil
   8     assert ! cond, msg
   9   end
  10
  11   def setup
  12     @lex = RubyLexer.new
  13     @lex.src = StringIO.new("blah blah")
  14     @lex.lex_state = :expr_beg # HACK ? I have no idea actually
  15   end
  16
  17   def test_advance
  18     assert @lex.advance # blah
  19     assert @lex.advance # blah
  20     deny   @lex.advance # nada
  21   end
  22
  23   def test_is_next_identchar
  24     assert @lex.is_next_identchar
  25     @lex.src = StringIO.new(" ")
  26     deny @lex.is_next_identchar
  27     @lex.src = StringIO.new("-")
  28     deny @lex.is_next_identchar
  29   end
  30
  31   def test_is_next_no_case # TODO: worst name evah
  32     @lex.src = StringIO.new("123 456")
  33     assert @lex.is_next_no_case("123")
  34     pos = @lex.src.pos
  35     deny @lex.is_next_no_case("begin")
  36     assert_equal " 456", @lex.src.read_all, "must put back contents"
  37   end
  38
  39   def test_number_token
  40     node = @lex.number_token("42", false, "\0")
  41     assert_equal :tINTEGER, node
  42     assert_equal 42, @lex.yacc_value
  43   end
  44
  45   def test_parse_number
  46     @lex.src = StringIO.new '42'
  47     node = @lex.parse_number('1')
  48     assert_equal :tINTEGER, node
  49     assert_equal 142, @lex.yacc_value
  50   end
  51
  52   def test_parse_quote
  53     @lex.src = StringIO.new 'blah)'
  54     node = @lex.parse_quote('(')
  55     assert_equal :tSTRING_BEG, node
  56     assert_equal s(:strterm, RubyLexer::STR_DQUOTE, ")", "("), @lex.lex_strterm
  57     assert_equal ["%)"], @lex.yacc_value.args # FIX double check this
  58   end
  59
  60   def test_yylex_integer
  61     util_lex_token "42", :tINTEGER, 42
  62   end
  63
  64   def test_yylex_integer_eh_a
  65     util_lex_token('?a',
  66                    :tINTEGER,     97)
  67   end
  68
  69   def test_yylex_integer_eh_escape_M_escape_C
  70     util_lex_token('?\M-\C-a',
  71                    :tINTEGER,     129)
  72   end
  73
  74   def test_yylex_float
  75     util_lex_token "1.0", :tFLOAT, 1.0
  76   end
  77
  78   def test_yylex_constant
  79     util_lex_token("ArgumentError",
  80                    :tCONSTANT, t("ArgumentError"))
  81   end
  82
  83   def test_yylex_constant_semi
  84     util_lex_token("ArgumentError;",
  85                    :tCONSTANT, t("ArgumentError"),
  86                    ";", t(";"))
  87   end
  88
  89   def test_yylex_identifier
  90     util_lex_token("identifier",
  91                    :tIDENTIFIER, t("identifier"))
  92   end
  93
  94   def test_yylex_regexp
  95     util_lex_token("/regexp/",
  96                    :tREGEXP_BEG,     t("/"),
  97                    :tSTRING_CONTENT, s(:str, "regexp"),
  98                    :tREGEXP_END,     "")
  99   end
 100
 101   def test_yylex_regexp_nm
 102     util_lex_token("/.*/nm",
 103                    :tREGEXP_BEG,     t("/"),
 104                    :tSTRING_CONTENT, s(:str, ".*"),
 105                    :tREGEXP_END,     "nm")
 106   end
 107
 108   def test_yylex_regexp_escapes
 109     util_lex_token('/re\tge\nxp/',
 110                    :tREGEXP_BEG,     t("/"),
 111                    :tSTRING_CONTENT, s(:str, "re\\tge\\nxp"),
 112                    :tREGEXP_END,     "")
 113   end
 114
 115   def test_yylex_regexp_escape_oct
 116     util_lex_token('/re\tge\101xp/',
 117                    :tREGEXP_BEG,     t("/"),
 118                    :tSTRING_CONTENT, s(:str, "re\\tge\\101xp"),
 119                    :tREGEXP_END,     "")
 120   end
 121
 122   def test_yylex_regexp_escape_hex
 123     util_lex_token('/re\tge\x61xp/',
 124                    :tREGEXP_BEG,     t("/"),
 125                    :tSTRING_CONTENT, s(:str, "re\\tge\\x61xp"),
 126                    :tREGEXP_END,     "")
 127   end
 128
 129   def test_yylex_string_double
 130     util_lex_token('"string"',
 131                    :tSTRING_BEG,     t('"'),
 132                    :tSTRING_CONTENT, s(:str, "string"),
 133                    :tSTRING_END,     t('"'))
 134   end
 135
 136   def test_yylex_string_double_escapes
 137     util_lex_token('"s\tri\ng"',
 138                    :tSTRING_BEG,     t('"'),
 139                    :tSTRING_CONTENT, s(:str, "s\tri\ng"),
 140                    :tSTRING_END,     t('"'))
 141   end
 142
 143   def test_yylex_string_double_escape_M
 144     util_lex_token('"\M-g"',
 145                    :tSTRING_BEG,     t('"'),
 146                    :tSTRING_CONTENT, s(:str, "\347"),
 147                    :tSTRING_END,     t('"'))
 148   end
 149
 150   def test_yylex_string_double_escape_octal
 151     util_lex_token('"n = \101\102\103"',
 152                    :tSTRING_BEG,     t('"'),
 153                    :tSTRING_CONTENT, s(:str, "n = ABC"),
 154                    :tSTRING_END,     t('"'))
 155   end
 156
 157   def test_yylex_string_double_escape_hex
 158     util_lex_token('"n = \x61\x62\x63"',
 159                    :tSTRING_BEG,     t('"'),
 160                    :tSTRING_CONTENT, s(:str, "n = abc"),
 161                    :tSTRING_END,     t('"'))
 162   end
 163
 164   def test_yylex_string_single
 165     util_lex_token("'string'",
 166                    :tSTRING_BEG,     t("'"),
 167                    :tSTRING_CONTENT, s(:str, "string"),
 168                    :tSTRING_END,     t("'"))
 169   end
 170
 171   def test_yylex_string_pct_Q
 172     util_lex_token("%Q[string]",
 173                    :tSTRING_BEG,     t("%Q["),
 174                    :tSTRING_CONTENT, s(:str, "string"),
 175                    :tSTRING_END,     t("]"))
 176   end
 177
 178   def test_yylex_string_single_escapes
 179     util_lex_token("'s\\tri\\ng'",
 180                    :tSTRING_BEG,     t("'"),
 181                    :tSTRING_CONTENT, s(:str, "s\\tri\\ng"),
 182                    :tSTRING_END,     t("'"))
 183   end
 184
 185   def test_yylex_global
 186     util_lex_token("$blah",
 187                    :tGVAR,     t("$blah"))
 188   end
 189
 190   def test_yylex_global_wierd
 191     util_lex_token("$__blah",
 192                    :tGVAR,     t("$__blah"))
 193   end
 194
 195   def test_yylex_global_dollar_underscore
 196     util_lex_token("$_",
 197                    :tGVAR,     t("$_"))
 198   end
 199
 200   def test_yylex_symbol
 201     util_lex_token(":symbol",
 202                    :tSYMBEG, t(":"),
 203                    :tIDENTIFIER, t("symbol"))
 204   end
 205
 206   def test_yylex_comment_begin
 207     util_lex_token("=begin\nblah\nblah\n=end\n42",
 208                    :tINTEGER, 42)
 209   end
 210
 211   def util_lex_token input, *args
 212     @lex.src = StringIO.new input
 213
 214     until args.empty? do
 215       token = args.shift
 216       value = args.shift
 217       assert @lex.advance, "no more tokens"
 218       assert_equal [token, value], [@lex.token, @lex.yacc_value]
 219     end
 220
 221     deny @lex.advance, "must be empty, but had #{[@lex.token, @lex.yacc_value].inspect}"
 222   end
 223 end
 224
 225 class TestStackState < Test::Unit::TestCase
 226   def test_stack_state
 227     s = StackState.new :test
 228     s.push true
 229     s.push false
 230     s.lexpop
 231     assert_equal [false, true], s.stack
 232   end
 233
 234   def test_is_in_state
 235     s = StackState.new :test
 236     assert_equal false, s.is_in_state
 237     s.push false
 238     assert_equal false, s.is_in_state
 239     s.push true
 240     assert_equal true, s.is_in_state
 241     s.push false
 242     assert_equal false, s.is_in_state
 243   end
 244
 245   def test_lexpop
 246     s = StackState.new :test
 247     assert_equal [false], s.stack
 248     s.push true
 249     s.push false
 250     assert_equal [false, true, false], s.stack
 251     s.lexpop
 252     assert_equal [false, true], s.stack
 253   end
 254
 255   def test_pop
 256     s = StackState.new :test
 257     assert_equal [false], s.stack
 258     s.push true
 259     assert_equal [false, true], s.stack
 260     assert_equal true, s.pop
 261     assert_equal [false], s.stack
 262   end
 263
 264   def test_push
 265     s = StackState.new :test
 266     assert_equal [false], s.stack
 267     s.push true
 268     s.push false
 269     assert_equal [false, true, false], s.stack
 270   end
 271 end
 272
 273 class TestEnvironment < Test::Unit::TestCase
 274   def deny t
 275     assert ! t
 276   end
 277
 278   def setup
 279     @env = Environment.new
 280     @env[:blah] = 42
 281     assert_equal 42, @env[:blah]
 282   end
 283
 284   def test_use
 285     @env.use :blah
 286     expected = [{ :blah => true }]
 287     assert_equal expected, @env.instance_variable_get(:"@use")
 288   end
 289
 290   def test_use_scoped
 291     @env.use :blah
 292     @env.extend
 293     expected = [{}, { :blah => true }]
 294     assert_equal expected, @env.instance_variable_get(:"@use")
 295   end
 296
 297   def test_used_eh
 298     @env.extend :dynamic
 299     @env[:x] = :dvar
 300     @env.use :x
 301     assert_equal true, @env.used?(:x)
 302   end
 303
 304   def test_used_eh_none
 305     assert_equal nil, @env.used?(:x)
 306   end
 307
 308   def test_used_eh_scoped
 309     self.test_used_eh
 310     @env.extend :dynamic
 311     assert_equal true, @env.used?(:x)
 312   end
 313
 314   def test_var_scope_dynamic
 315     @env.extend :dynamic
 316     assert_equal 42, @env[:blah]
 317     @env.unextend
 318     assert_equal 42, @env[:blah]
 319   end
 320
 321   def test_var_scope_static
 322     @env.extend
 323     assert_equal nil, @env[:blah]
 324     @env.unextend
 325     assert_equal 42, @env[:blah]
 326   end
 327
 328   def test_dynamic
 329     expected1 = {}
 330     expected2 = { :x => 42 }
 331
 332     assert_equal expected1, @env.dynamic
 333     begin
 334       @env.extend :dynamic
 335       assert_equal expected1, @env.dynamic
 336
 337       @env[:x] = 42
 338       assert_equal expected2, @env.dynamic
 339
 340       begin
 341         @env.extend :dynamic
 342         assert_equal expected2, @env.dynamic
 343         @env.unextend
 344       end
 345
 346       assert_equal expected2, @env.dynamic
 347       @env.unextend
 348     end
 349     assert_equal expected1, @env.dynamic
 350   end
 351
 352   def test_all_dynamic
 353     expected = { :blah => 42 }
 354
 355     @env.extend :dynamic
 356     assert_equal expected, @env.all
 357     @env.unextend
 358     assert_equal expected, @env.all
 359   end
 360
 361   def test_all_static
 362     @env.extend
 363     expected = { }
 364     assert_equal expected, @env.all
 365
 366     @env.unextend
 367     expected = { :blah => 42 }
 368     assert_equal expected, @env.all
 369   end
 370
 371   def test_dynamic_eh
 372     assert_equal false, @env.dynamic?
 373     @env.extend :dynamic
 374     assert_equal true, @env.dynamic?
 375     @env.extend
 376     assert_equal false, @env.dynamic?
 377   end
 378
 379   def test_all_static_deeper
 380     expected0 = { :blah => 42 }
 381     expected1 = { :blah => 42, :blah2 => 24 }
 382     expected2 = { :blah => 27 }
 383
 384     @env.extend :dynamic
 385     @env[:blah2] = 24
 386     assert_equal expected1, @env.all
 387
 388     @env.extend
 389     @env[:blah] = 27
 390     assert_equal expected2, @env.all
 391
 392     @env.unextend
 393     assert_equal expected1, @env.all
 394
 395     @env.unextend
 396     assert_equal expected0, @env.all
 397   end
 398 end