third-party/mruby/test/t/syntax.rb

   1 assert('__FILE__') do
   2   file = __FILE__[-9, 9]
   3   assert_equal 'syntax.rb', file
   4 end
   5
   6 assert('__LINE__') do
   7   assert_equal 7, __LINE__
   8 end
   9
  10 assert('super', '11.3.4') do
  11   assert_raise NoMethodError do
  12     super
  13   end
  14
  15   class SuperFoo
  16     def foo
  17       true
  18     end
  19     def bar(*a)
  20       a
  21     end
  22   end
  23   class SuperBar < SuperFoo
  24     def foo
  25       super
  26     end
  27     def bar(*a)
  28       super(*a)
  29     end
  30   end
  31   bar = SuperBar.new
  32
  33   assert_true bar.foo
  34   assert_equal [1,2,3], bar.bar(1,2,3)
  35 end
  36
  37 assert('yield', '11.3.5') do
  38   assert_raise LocalJumpError do
  39     yield
  40   end
  41   assert_raise LocalJumpError do
  42     o = Object.new
  43     def o.foo
  44       yield
  45     end
  46     o.foo
  47   end
  48 end
  49
  50 assert('redo in a for loop (#3275)') do
  51   sum = 0
  52   for i in 1..10
  53     sum += i
  54     i -= 1
  55     if i > 0
  56       redo
  57     end
  58   end
  59
  60   assert_equal 220, sum
  61 end
  62
  63 assert('Abbreviated variable assignment', '11.4.2.3.2') do
  64   a ||= 1
  65   b &&= 1
  66   c = 1
  67   c += 2
  68
  69   assert_equal 1, a
  70   assert_nil b
  71   assert_equal 3, c
  72 end
  73
  74 assert('case expression', '11.5.2.2.4') do
  75   # case-expression-with-expression, one when-clause
  76   x = 0
  77   case "a"
  78   when "a"
  79     x = 1
  80   end
  81   assert_equal 1, x
  82
  83   # case-expression-with-expression, multiple when-clauses
  84   x = 0
  85   case "b"
  86   when "a"
  87     x = 1
  88   when "b"
  89     x = 2
  90   end
  91   assert_equal 2, x
  92
  93   # no matching when-clause
  94   x = 0
  95   case "c"
  96   when "a"
  97     x = 1
  98   when "b"
  99     x = 2
 100   end
 101   assert_equal 0, x
 102
 103   # case-expression-with-expression, one when-clause and one else-clause
 104   a = 0
 105   case "c"
 106   when "a"
 107     x = 1
 108   else
 109     x = 3
 110   end
 111   assert_equal 3, x
 112
 113   # case-expression-without-expression, one when-clause
 114   x = 0
 115   case
 116   when true
 117     x = 1
 118   end
 119   assert_equal 1, x
 120
 121   # case-expression-without-expression, multiple when-clauses
 122   x = 0
 123   case
 124   when 0 == 1
 125     x = 1
 126   when 1 == 1
 127     x = 2
 128   end
 129   assert_equal 2, x
 130
 131   # case-expression-without-expression, one when-clause and one else-clause
 132   x = 0
 133   case
 134   when 0 == 1
 135     x = 1
 136   else
 137     x = 3
 138   end
 139   assert_equal 3, x
 140
 141   # multiple when-arguments
 142   x = 0
 143   case 4
 144   when 1, 3, 5
 145     x = 1
 146   when 2, 4, 6
 147     x = 2
 148   end
 149   assert_equal 2, x
 150
 151   # when-argument with splatting argument
 152   x = :integer
 153   odds  = [ 1, 3, 5, 7, 9 ]
 154   evens = [ 2, 4, 6, 8 ]
 155   case 5
 156   when *odds
 157     x = :odd
 158   when *evens
 159     x = :even
 160   end
 161   assert_equal :odd, x
 162
 163   true
 164 end
 165
 166 assert('Nested const reference') do
 167   module Syntax4Const
 168     CONST1 = "hello world"
 169     class Const2
 170       def const1
 171         CONST1
 172       end
 173     end
 174   end
 175   assert_equal "hello world", Syntax4Const::CONST1
 176   assert_equal "hello world", Syntax4Const::Const2.new.const1
 177 end
 178
 179 assert('Abbreviated variable assignment as returns') do
 180   module Syntax4AbbrVarAsgnAsReturns
 181     class A
 182       def b
 183         @c ||= 1
 184       end
 185     end
 186   end
 187   assert_equal 1, Syntax4AbbrVarAsgnAsReturns::A.new.b
 188 end
 189
 190 assert('Splat and multiple assignment') do
 191   *a = *[1,2,3]
 192   b, *c = *[7,8,9]
 193
 194   assert_equal [1,2,3], a
 195   assert_equal 7, b
 196   assert_equal [8,9], c
 197
 198   (a, b), c = [1,2],3
 199   assert_equal [1,2,3], [a,b,c]
 200   (a, b), c = 1,2,3
 201   assert_equal [1,nil,2], [a,b,c]
 202 end
 203
 204 assert('Splat and multiple assignment from variable') do
 205   a = [1, 2, 3]
 206   b, *c = a
 207
 208   assert_equal 1, b
 209   assert_equal [2, 3], c
 210 end
 211
 212 assert('Splat and multiple assignment from variables') do
 213   a = [1, 2, 3]
 214   b = [4, 5, 6, 7]
 215   c, d, *e, f, g = *a, *b
 216
 217   assert_equal 1, c
 218   assert_equal 2, d
 219   assert_equal [3, 4, 5], e
 220   assert_equal 6, f
 221   assert_equal 7, g
 222 end
 223
 224 assert('Splat and multiple assignment in for') do
 225   a = [1, 2, 3, 4, 5, 6, 7]
 226   for b, c, *d, e, f in [a] do
 227   end
 228
 229   assert_equal 1, b
 230   assert_equal 2, c
 231   assert_equal [3, 4, 5], d
 232   assert_equal 6, e
 233   assert_equal 7, f
 234 end
 235
 236 assert('Splat without assignment') do
 237   * = [0]
 238   a, * = [1, 2]
 239   assert_equal 1, a
 240 end
 241
 242 assert('multiple assignment (rest)') do
 243   *a = 0
 244   assert_equal [0], a
 245 end
 246
 247 assert('multiple assignment (rest+post)') do
 248   *a, b = 0, 1, 2
 249   *c, d = 3
 250
 251   assert_equal [0, 1], a
 252   assert_equal 2, b
 253   assert_equal [], c
 254   assert_equal 3, d
 255 end
 256
 257 assert('multiple assignment (nosplat array rhs)') do
 258   a, *b = []
 259   *c, d = [0]
 260   e, *f, g = [1, 2]
 261
 262   assert_nil a
 263   assert_equal [], b
 264   assert_equal [], c
 265   assert_equal 0, d
 266   assert_equal 1, e
 267   assert_equal [], f
 268   assert_equal 2, g
 269 end
 270
 271 assert('multiple assignment (empty array rhs #3236, #3239)') do
 272   a,b,*c = []; assert_equal [nil, nil, []], [a, b, c]
 273   a,b,*c = [1]; assert_equal [1, nil, []], [a, b, c]
 274   a,b,*c = [nil]; assert_equal [nil,nil, []], [a, b, c]
 275   a,b,*c = [[]]; assert_equal [[], nil, []], [a, b, c]
 276 end
 277
 278 assert('Return values of case statements') do
 279   a = [] << case 1
 280   when 3 then 2
 281   when 2 then 2
 282   when 1 then 2
 283   end
 284
 285   b = [] << case 1
 286   when 2 then 2
 287   else
 288   end
 289
 290   def fb
 291     n = 0
 292     Proc.new do
 293       n += 1
 294       case
 295       when n % 15 == 0
 296       else n
 297       end
 298     end
 299   end
 300
 301   assert_equal [2], a
 302   assert_equal [nil], b
 303   assert_equal 1, fb.call
 304 end
 305
 306 assert('Return values of if and case statements') do
 307   true_clause_value =
 308     if true
 309       1
 310     else
 311       case 2
 312       when 3
 313       end
 314       4
 315     end
 316
 317   assert_equal 1, true_clause_value
 318 end
 319
 320 assert('Return values of no expression case statement') do
 321   when_value =
 322     case
 323     when true
 324       1
 325     end
 326
 327   assert_equal 1, when_value
 328 end
 329
 330 assert('splat object in assignment') do
 331   o = Object.new
 332   def o.to_a
 333     nil
 334   end
 335   assert_equal [o], (a = *o)
 336
 337   def o.to_a
 338     1
 339   end
 340   assert_raise(TypeError) { a = *o }
 341
 342   def o.to_a
 343     [2]
 344   end
 345   assert_equal [2], (a = *o)
 346 end
 347
 348 assert('splat object in case statement') do
 349   o = Object.new
 350   def o.to_a
 351     nil
 352   end
 353   a = case o
 354   when *o
 355     1
 356   end
 357   assert_equal 1, a
 358 end
 359
 360 assert('splat in case statement') do
 361   values = [3,5,1,7,8]
 362   testa = [1,2,7]
 363   testb = [5,6]
 364   resulta = []
 365   resultb = []
 366   resultc = []
 367   values.each do |value|
 368     case value
 369     when *testa
 370       resulta << value
 371     when *testb
 372       resultb << value
 373     else
 374       resultc << value
 375     end
 376   end
 377
 378   assert_equal [1,7], resulta
 379   assert_equal [5], resultb
 380   assert_equal [3,8], resultc
 381 end
 382
 383 assert('External command execution.') do
 384   module Kernel
 385     sym = '`'.to_sym
 386     alias_method :old_cmd, sym
 387
 388     results = []
 389     define_method(sym) do |str|
 390       results.push str
 391       str
 392     end
 393
 394     `test` # NOVAL NODE_XSTR
 395     `test dynamic #{sym}` # NOVAL NODE_DXSTR
 396     assert_equal ['test', 'test dynamic `'], results
 397
 398     t = `test` # VAL NODE_XSTR
 399     assert_equal 'test', t
 400     assert_equal ['test', 'test dynamic `', 'test'], results
 401
 402     t = `test dynamic #{sym}` # VAL NODE_DXSTR
 403     assert_equal 'test dynamic `', t
 404     assert_equal ['test', 'test dynamic `', 'test', 'test dynamic `'], results
 405
 406     results = []
 407     assert_equal 'test sym test sym test', `test #{:sym} test #{:sym} test`
 408
 409     alias_method sym, :old_cmd
 410   end
 411   true
 412 end
 413
 414 assert('parenthesed do-block in cmdarg') do
 415   class ParenDoBlockCmdArg
 416     def test(block)
 417       block.call
 418     end
 419   end
 420   x = ParenDoBlockCmdArg.new
 421   result = x.test (Proc.new do :ok; end)
 422   assert_equal :ok, result
 423 end
 424
 425 assert('method definition in cmdarg') do
 426   result = class MethodDefinitionInCmdarg
 427     def self.bar(arg); arg end
 428     bar def foo; self.each do end end
 429   end
 430   assert_equal(:foo, result)
 431 end
 432
 433 assert('optional argument in the rhs default expressions') do
 434   class OptArgInRHS
 435     def foo
 436       "method called"
 437     end
 438     def t(foo = foo)
 439       foo
 440     end
 441     def t2(foo = foo())
 442       foo
 443     end
 444   end
 445   o = OptArgInRHS.new
 446   assert_nil(o.t)
 447   assert_equal("method called", o.t2)
 448 end
 449
 450 assert('optional block argument in the rhs default expressions') do
 451   assert_nil(Proc.new {|foo = foo| foo}.call)
 452 end
 453
 454 assert('local variable definition in default value and subsequent arguments') do
 455   def m(a = b = 1, c) [a, b, c] end
 456   assert_equal([1, 1, :c], m(:c))
 457   assert_equal([:a, nil, :c], m(:a, :c))
 458
 459   def m(a = b = 1, &c) [a, b, c ? true : nil] end
 460   assert_equal([1, 1, nil], m)
 461   assert_equal([1, 1, true], m{})
 462   assert_equal([:a, nil, nil], m(:a))
 463   assert_equal([:a, nil, true], m(:a){})
 464 end
 465
 466 assert('multiline comments work correctly') do
 467 =begin
 468 this is a comment with nothing after begin and end
 469 =end
 470 =begin  this is a comment
 471 this is a comment with extra after =begin
 472 =end
 473 =begin
 474 this is a comment that has =end with spaces after it
 475 =end
 476 =begin this is a comment
 477 this is a comment that has extra after =begin and =end with spaces after it
 478 =end
 479   line = __LINE__
 480 =begin  this is a comment
 481 this is a comment that has extra after =begin and =end with tabs after it
 482 =end    xxxxxxxxxxxxxxxxxxxxxxxxxx
 483   assert_equal(line + 4, __LINE__)
 484 end
 485
 486 assert 'keyword arguments' do
 487   def m(a, b:1) [a, b] end
 488   assert_equal [1, 1], m(1)
 489   assert_equal [1, 2], m(1, b: 2)
 490
 491   def m(a, b:) [a, b] end
 492   assert_equal [1, 2], m(1, b: 2)
 493   assert_raise(ArgumentError) { m b: 1 }
 494   assert_raise(ArgumentError) { m 1 }
 495
 496   def m(a:) a end
 497   assert_equal 1, m(a: 1)
 498   assert_raise(ArgumentError) { m }
 499   assert_raise(ArgumentError) { m 'a'  => 1, a: 1 }
 500   h = { a: 1 }
 501   assert_equal 1, m(h)
 502   assert_equal({ a: 1 }, h)
 503
 504   def m(a: 1) a end
 505   assert_equal 1, m
 506   assert_equal 2, m(a: 2)
 507   assert_raise(ArgumentError) { m 1 }
 508
 509   def m(**) end
 510   assert_nil m
 511   assert_nil m a: 1, b: 2
 512   assert_raise(ArgumentError) { m 2 }
 513
 514   def m(a, **) a end
 515   assert_equal 1, m(1)
 516   assert_equal 1, m(1, a: 2, b: 3)
 517   assert_equal({ 'a' => 1, b: 2 }, m('a' => 1, b: 2))
 518
 519   def m(a, **k) [a, k] end
 520   assert_equal [1, {}], m(1)
 521   assert_equal [1, {a: 2, b: 3}], m(1, a: 2, b: 3)
 522   assert_equal [{'a' => 1, b: 2}, {}], m('a' => 1, b: 2)
 523
 524   def m(a=1, **) a end
 525   assert_equal 1, m
 526   assert_equal 2, m(2, a: 1, b: 0)
 527   assert_raise(ArgumentError) { m('a' => 1, a: 2) }
 528
 529   def m(a=1, **k) [a, k] end
 530   assert_equal [1, {}], m
 531   assert_equal [1, {a: 1}], m(a: 1)
 532   assert_equal [2, {a: 1, b: 2}], m(2, a: 1, b: 2)
 533   assert_equal [{a: 1}, {b: 2}], m({a: 1}, {b: 2})
 534
 535   def m(*, a:) a end
 536   assert_equal 1, m(a: 1)
 537   assert_equal 3, m(1, 2, a: 3)
 538   assert_raise(ArgumentError) { m('a' => 1, a: 2) }
 539
 540   def m(*a, b:) [a, b] end
 541   assert_equal [[], 1], m(b: 1)
 542   assert_equal [[1, 2], 3], m(1, 2, b: 3)
 543   assert_raise(ArgumentError) { m('a' => 1, b: 2) }
 544
 545   def m(*a, b: 1) [a, b] end
 546   assert_equal [[], 1], m
 547   assert_equal [[1, 2, 3], 4], m(1, 2, 3, b: 4)
 548   assert_raise(ArgumentError) { m('a' => 1, b: 2) }
 549
 550   def m(*, **) end
 551   assert_nil m()
 552   assert_nil m(a: 1, b: 2)
 553   assert_nil m(1, 2, 3, a: 4, b: 5)
 554
 555   def m(*a, **) a end
 556   assert_equal [], m()
 557   assert_equal [1, 2, 3], m(1, 2, 3, a: 4, b: 5)
 558   assert_raise(ArgumentError) { m("a" => 1, a: 1) }
 559   assert_equal [1], m(1, **{a: 2})
 560
 561   def m(*, **k) k end
 562   assert_equal({}, m())
 563   assert_equal({a: 4, b: 5}, m(1, 2, 3, a: 4, b: 5))
 564   assert_raise(ArgumentError) { m("a" => 1, a: 1) }
 565
 566   def m(a = nil, b = nil, **k) [a, k] end
 567   assert_equal [nil, {}], m()
 568   assert_equal([nil, {a: 1}], m(a: 1))
 569   assert_raise(ArgumentError) { m("a" => 1, a: 1) }
 570   assert_equal([{"a" => 1}, {a: 1}], m({ "a" => 1 }, a: 1))
 571   assert_equal([{a: 1}, {}], m({a: 1}, {}))
 572   assert_equal([nil, {}], m({}))
 573
 574   def m(*a, **k) [a, k] end
 575   assert_equal([[], {}], m())
 576   assert_equal([[1], {}], m(1))
 577   assert_equal([[], {a: 1, b: 2}], m(a: 1, b: 2))
 578   assert_equal([[1, 2, 3], {a: 2}], m(1, 2, 3, a: 2))
 579   assert_raise(ArgumentError) { m("a" => 1, a: 1) }
 580   assert_raise(ArgumentError) { m("a" => 1) }
 581   assert_equal([[], {a: 1}], m(a: 1))
 582   assert_raise(ArgumentError) { m("a" => 1, a: 1) }
 583   assert_equal([[{"a" => 1}], {a: 1}], m({ "a" => 1 }, a: 1))
 584   assert_equal([[{a: 1}], {}], m({a: 1}, {}))
 585   assert_raise(ArgumentError) { m({a: 1}, {"a" => 1}) }
 586
 587   def m(a:, b:) [a, b] end
 588   assert_equal([1, 2], m(a: 1, b: 2))
 589   assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 590
 591   def m(a:, b: 1) [a, b] end
 592   assert_equal([1, 1], m(a: 1))
 593   assert_equal([1, 2], m(a: 1, b: 2))
 594   assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 595
 596   def m(a:, **) a end
 597   assert_equal(1, m(a: 1))
 598   assert_equal(1, m(a: 1, b: 2))
 599   assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 600
 601   def m(a:, **k) [a, k] end
 602   assert_equal([1, {}], m(a: 1))
 603   assert_equal([1, {b: 2, c: 3}], m(a: 1, b: 2, c: 3))
 604   assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 605
 606 =begin
 607   def m(a:, &b) [a, b] end
 608   assert_equal([1, nil], m(a: 1))
 609   assert_equal([1, l], m(a: 1, &(l = ->{})))
 610 =end
 611
 612   def m(a: 1, b:) [a, b] end
 613   assert_equal([1, 0], m(b: 0))
 614   assert_equal([3, 2], m(b: 2, a: 3))
 615   assert_raise(ArgumentError) { m a: 1 }
 616
 617   def m(a: def m(a: 1) a end, b:)
 618     [a, b]
 619   end
 620   assert_equal([2, 3], m(a: 2, b: 3))
 621   assert_equal([:m, 1], m(b: 1))
 622   # Note the default value of a: in the original method.
 623   assert_equal(1, m())
 624
 625   def m(a: 1, b: 2) [a, b] end
 626   assert_equal([1, 2], m())
 627   assert_equal([4, 3], m(b: 3, a: 4))
 628
 629   def m(a: 1, **) a end
 630   assert_equal(1, m())
 631   assert_equal(2, m(a: 2, b: 1))
 632
 633   def m(a: 1, **k) [a, k] end
 634   assert_equal([1, {b: 2, c: 3}], m(b: 2, c: 3))
 635
 636   def m(a:, **) yield end
 637   assert_raise(ArgumentError) { m { :blk } }
 638   assert_equal :blk, m(a: 1){ :blk }
 639
 640   def m(a:, **k, &b) [b.call, k] end
 641   assert_raise(ArgumentError) { m { :blk } }
 642   assert_equal [:blk, {b: 2}], m(a: 1, b: 2){ :blk }
 643
 644   def m(**k, &b) [k, b] end
 645   assert_equal([{ a: 1, b: 2}, nil], m(a: 1, b: 2))
 646   assert_equal :blk, m{ :blk }[1].call
 647
 648   def m(hsh = {}) hsh end
 649   assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2))
 650   assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2))
 651
 652   def m(hsh) hsh end
 653   assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2))
 654   assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2))
 655
 656 =begin
 657   def m(a, b=1, *c, (*d, (e)), f: 2, g:, h:, **k, &l)
 658     [a, b, c, d, e, f, g, h, k, l]
 659   end
 660   result = m(9, 8, 7, 6, f: 5, g: 4, h: 3, &(l = ->{}))
 661   assert_equal([9, 8, [7], [], 6, 5, 4, 3, {}, l], result)
 662
 663   def m a, b=1, *c, d, e:, f: 2, g:, **k, &l
 664     [a, b, c, d, e, f, g, k, l]
 665   end
 666   result = m(1, 2, e: 3, g: 4, h: 5, i: 6, &(l = ->{}))
 667   assert_equal([1, 1, [], 2, 3, 2, 4, { h: 5, i: 6 }, l], result)
 668 =end
 669
 670   def m(a: b = 1, c:) [a, b, c] end
 671   assert_equal([1, 1, :c], m(c: :c))
 672   assert_equal([:a, nil, :c], m(a: :a, c: :c))
 673 end
 674
 675 assert('numbered parameters') do
 676   assert_equal(15, [1,2,3,4,5].reduce {_1+_2})
 677   assert_equal(45, Proc.new do _1 + _2 + _3 + _4 + _5 + _6 + _7 + _8 + _9 end.call(*[1, 2, 3, 4, 5, 6, 7, 8, 9]))
 678 end
 679
 680 assert('_0 is not numbered parameter') do
 681   _0 = :l
 682   assert_equal(:l, ->{_0}.call)
 683 end