3 assert_equal 'syntax.rb', file
7 assert_equal 7, __LINE__
10 assert('super', '11.3.4') do
11 assert_raise NoMethodError do
23 class SuperBar < SuperFoo
34 assert_equal [1,2,3], bar.bar(1,2,3)
37 assert('yield', '11.3.5') do
38 assert_raise LocalJumpError do
41 assert_raise LocalJumpError do
50 assert('redo in a for loop (#3275)') do
63 assert('Abbreviated variable assignment', '11.4.2.3.2') do
74 assert('case expression', '11.5.2.2.4') do
75 # case-expression-with-expression, one when-clause
83 # case-expression-with-expression, multiple when-clauses
93 # no matching when-clause
103 # case-expression-with-expression, one when-clause and one else-clause
113 # case-expression-without-expression, one when-clause
121 # case-expression-without-expression, multiple when-clauses
131 # case-expression-without-expression, one when-clause and one else-clause
141 # multiple when-arguments
151 # when-argument with splatting argument
153 odds = [ 1, 3, 5, 7, 9 ]
154 evens = [ 2, 4, 6, 8 ]
166 assert('Nested const reference') do
168 CONST1 = "hello world"
175 assert_equal "hello world", Syntax4Const::CONST1
176 assert_equal "hello world", Syntax4Const::Const2.new.const1
179 assert('Abbreviated variable assignment as returns') do
180 module Syntax4AbbrVarAsgnAsReturns
187 assert_equal 1, Syntax4AbbrVarAsgnAsReturns::A.new.b
190 assert('Splat and multiple assignment') do
194 assert_equal [1,2,3], a
196 assert_equal [8,9], c
199 assert_equal [1,2,3], [a,b,c]
201 assert_equal [1,nil,2], [a,b,c]
204 assert('Splat and multiple assignment from variable') do
209 assert_equal [2, 3], c
212 assert('Splat and multiple assignment from variables') do
215 c, d, *e, f, g = *a, *b
219 assert_equal [3, 4, 5], e
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
231 assert_equal [3, 4, 5], d
236 assert('Splat without assignment') do
242 assert('multiple assignment (rest)') do
247 assert('multiple assignment (rest+post)') do
251 assert_equal [0, 1], a
257 assert('multiple assignment (nosplat array rhs)') do
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]
278 assert('Return values of case statements') do
302 assert_equal [nil], b
303 assert_equal 1, fb.call
306 assert('Return values of if and case statements') do
317 assert_equal 1, true_clause_value
320 assert('Return values of no expression case statement') do
327 assert_equal 1, when_value
330 assert('splat object in assignment') do
335 assert_equal [o], (a = *o)
340 assert_raise(TypeError) { a = *o }
345 assert_equal [2], (a = *o)
348 assert('splat object in case statement') do
360 assert('splat in case statement') do
367 values.each do |value|
378 assert_equal [1,7], resulta
379 assert_equal [5], resultb
380 assert_equal [3,8], resultc
383 assert('External command execution.') do
386 alias_method :old_cmd, sym
389 define_method(sym) do |str|
394 `test` # NOVAL NODE_XSTR
395 `test dynamic #{sym}` # NOVAL NODE_DXSTR
396 assert_equal ['test', 'test dynamic `'], results
398 t = `test` # VAL NODE_XSTR
399 assert_equal 'test', t
400 assert_equal ['test', 'test dynamic `', 'test'], results
402 t = `test dynamic #{sym}` # VAL NODE_DXSTR
403 assert_equal 'test dynamic `', t
404 assert_equal ['test', 'test dynamic `', 'test', 'test dynamic `'], results
407 assert_equal 'test sym test sym test', `test #{:sym} test #{:sym} test`
409 alias_method sym, :old_cmd
414 assert('parenthesed do-block in cmdarg') do
415 class ParenDoBlockCmdArg
420 x = ParenDoBlockCmdArg.new
421 result = x.test (Proc.new do :ok; end)
422 assert_equal :ok, result
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
430 assert_equal(:foo, result)
433 assert('optional argument in the rhs default expressions') do
447 assert_equal("method called", o.t2)
450 assert('optional block argument in the rhs default expressions') do
451 assert_nil(Proc.new {|foo = foo| foo}.call)
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))
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){})
466 assert('multiline comments work correctly') do
468 this is a comment with nothing after begin and end
470 =begin this is a comment
471 this is a comment with extra after =begin
474 this is a comment that has =end with spaces after it
476 =begin this is a comment
477 this is a comment that has extra after =begin and =end with spaces after it
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__)
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)
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 }
497 assert_equal 1, m(a: 1)
498 assert_raise(ArgumentError) { m }
499 assert_raise(ArgumentError) { m 'a' => 1, a: 1 }
502 assert_equal({ a: 1 }, h)
506 assert_equal 2, m(a: 2)
507 assert_raise(ArgumentError) { m 1 }
511 assert_nil m a: 1, b: 2
512 assert_raise(ArgumentError) { m 2 }
516 assert_equal 1, m(1, a: 2, b: 3)
517 assert_equal({ 'a' => 1, b: 2 }, m('a' => 1, b: 2))
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)
526 assert_equal 2, m(2, a: 1, b: 0)
527 assert_raise(ArgumentError) { m('a' => 1, a: 2) }
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})
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) }
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) }
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) }
552 assert_nil m(a: 1, b: 2)
553 assert_nil m(1, 2, 3, a: 4, b: 5)
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})
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) }
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({}))
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}) }
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) }
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) }
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) }
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) }
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 = ->{})))
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 }
617 def m(a: def m(a: 1) a end, b:)
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.
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))
629 def m(a: 1, **) a end
631 assert_equal(2, m(a: 2, b: 1))
633 def m(a: 1, **k) [a, k] end
634 assert_equal([1, {b: 2, c: 3}], m(b: 2, c: 3))
636 def m(a:, **) yield end
637 assert_raise(ArgumentError) { m { :blk } }
638 assert_equal :blk, m(a: 1){ :blk }
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 }
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
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))
653 assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2))
654 assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2))
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]
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)
663 def m a, b=1, *c, d, e:, f: 2, g:, **k, &l
664 [a, b, c, d, e, f, g, k, l]
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)
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))
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]))
680 assert('_0 is not numbered parameter') do
682 assert_equal(:l, ->{_0}.call)