1assert('__FILE__') do 2 file = __FILE__[-9, 9] 3 assert_equal 'syntax.rb', file 4end 5 6assert('__LINE__') do 7 assert_equal 7, __LINE__ 8end 9 10assert('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) 35end 36 37assert('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 48end 49 50assert('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 61end 62 63assert('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 72end 73 74assert('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 164end 165 166assert('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 177end 178 179assert('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 188end 189 190assert('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] 202end 203 204assert('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 210end 211 212assert('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 222end 223 224assert('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 234end 235 236assert('Splat without assignment') do 237 * = [0] 238 a, * = [1, 2] 239 assert_equal 1, a 240end 241 242assert('multiple assignment (rest)') do 243 *a = 0 244 assert_equal [0], a 245end 246 247assert('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 255end 256 257assert('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 269end 270 271assert('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] 276end 277 278assert('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 304end 305 306assert('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 318end 319 320assert('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 328end 329 330assert('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) 346end 347 348assert('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 358end 359 360assert('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 381end 382 383assert('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 412end 413 414assert('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 423end 424 425assert('method definition in cmdarg') do 426 if false 427 bar def foo; self.each do end end 428 end 429 true 430end 431 432assert('optional argument in the rhs default expressions') do 433 class OptArgInRHS 434 def foo 435 "method called" 436 end 437 def t(foo = foo) 438 foo 439 end 440 def t2(foo = foo()) 441 foo 442 end 443 end 444 o = OptArgInRHS.new 445 assert_nil(o.t) 446 assert_equal("method called", o.t2) 447end 448 449assert('optional block argument in the rhs default expressions') do 450 assert_nil(Proc.new {|foo = foo| foo}.call) 451end 452 453assert('multiline comments work correctly') do 454=begin 455this is a comment with nothing after begin and end 456=end 457=begin this is a comment 458this is a comment with extra after =begin 459=end 460=begin 461this is a comment that has =end with spaces after it 462=end 463=begin this is a comment 464this is a comment that has extra after =begin and =end with spaces after it 465=end 466 line = __LINE__ 467=begin this is a comment 468this is a comment that has extra after =begin and =end with tabs after it 469=end xxxxxxxxxxxxxxxxxxxxxxxxxx 470 assert_equal(line + 4, __LINE__) 471end 472 473assert 'keyword arguments' do 474 def m(a, b:1) [a, b] end 475 assert_equal [1, 1], m(1) 476 assert_equal [1, 2], m(1, b: 2) 477 478 def m(a, b:) [a, b] end 479 assert_equal [1, 2], m(1, b: 2) 480 assert_raise(ArgumentError) { m b: 1 } 481 assert_raise(ArgumentError) { m 1 } 482 483 def m(a:) a end 484 assert_equal 1, m(a: 1) 485 assert_raise(ArgumentError) { m } 486 assert_raise(ArgumentError) { m 'a' => 1, a: 1 } 487 h = { a: 1 } 488 assert_equal 1, m(h) 489 assert_equal({ a: 1 }, h) 490 491 def m(a: 1) a end 492 assert_equal 1, m 493 assert_equal 2, m(a: 2) 494 assert_raise(ArgumentError) { m 1 } 495 496 def m(**) end 497 assert_nil m 498 assert_nil m a: 1, b: 2 499 assert_raise(ArgumentError) { m 2 } 500 501 def m(a, **) a end 502 assert_equal 1, m(1) 503 assert_equal 1, m(1, a: 2, b: 3) 504 assert_equal({ 'a' => 1, b: 2 }, m('a' => 1, b: 2)) 505 506 def m(a, **k) [a, k] end 507 assert_equal [1, {}], m(1) 508 assert_equal [1, {a: 2, b: 3}], m(1, a: 2, b: 3) 509 assert_equal [{'a' => 1, b: 2}, {}], m('a' => 1, b: 2) 510 511 def m(a=1, **) a end 512 assert_equal 1, m 513 assert_equal 2, m(2, a: 1, b: 0) 514 assert_raise(ArgumentError) { m('a' => 1, a: 2) } 515 516 def m(a=1, **k) [a, k] end 517 assert_equal [1, {}], m 518 assert_equal [1, {a: 1}], m(a: 1) 519 assert_equal [2, {a: 1, b: 2}], m(2, a: 1, b: 2) 520 assert_equal [{a: 1}, {b: 2}], m({a: 1}, {b: 2}) 521 522 def m(*, a:) a end 523 assert_equal 1, m(a: 1) 524 assert_equal 3, m(1, 2, a: 3) 525 assert_raise(ArgumentError) { m('a' => 1, a: 2) } 526 527 def m(*a, b:) [a, b] end 528 assert_equal [[], 1], m(b: 1) 529 assert_equal [[1, 2], 3], m(1, 2, b: 3) 530 assert_raise(ArgumentError) { m('a' => 1, b: 2) } 531 532 def m(*a, b: 1) [a, b] end 533 assert_equal [[], 1], m 534 assert_equal [[1, 2, 3], 4], m(1, 2, 3, b: 4) 535 assert_raise(ArgumentError) { m('a' => 1, b: 2) } 536 537 def m(*, **) end 538 assert_nil m() 539 assert_nil m(a: 1, b: 2) 540 assert_nil m(1, 2, 3, a: 4, b: 5) 541 542 def m(*a, **) a end 543 assert_equal [], m() 544 assert_equal [1, 2, 3], m(1, 2, 3, a: 4, b: 5) 545 assert_raise(ArgumentError) { m("a" => 1, a: 1) } 546 assert_equal [1], m(1, **{a: 2}) 547 548 def m(*, **k) k end 549 assert_equal({}, m()) 550 assert_equal({a: 4, b: 5}, m(1, 2, 3, a: 4, b: 5)) 551 assert_raise(ArgumentError) { m("a" => 1, a: 1) } 552 553 def m(a = nil, b = nil, **k) [a, k] end 554 assert_equal [nil, {}], m() 555 assert_equal([nil, {a: 1}], m(a: 1)) 556 assert_raise(ArgumentError) { m("a" => 1, a: 1) } 557 assert_equal([{"a" => 1}, {a: 1}], m({ "a" => 1 }, a: 1)) 558 assert_equal([{a: 1}, {}], m({a: 1}, {})) 559 assert_equal([nil, {}], m({})) 560 561 def m(*a, **k) [a, k] end 562 assert_equal([[], {}], m()) 563 assert_equal([[1], {}], m(1)) 564 assert_equal([[], {a: 1, b: 2}], m(a: 1, b: 2)) 565 assert_equal([[1, 2, 3], {a: 2}], m(1, 2, 3, a: 2)) 566 assert_raise(ArgumentError) { m("a" => 1, a: 1) } 567 assert_raise(ArgumentError) { m("a" => 1) } 568 assert_equal([[], {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_raise(ArgumentError) { m({a: 1}, {"a" => 1}) } 573 574 def m(a:, b:) [a, b] end 575 assert_equal([1, 2], m(a: 1, b: 2)) 576 assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) } 577 578 def m(a:, b: 1) [a, b] end 579 assert_equal([1, 1], m(a: 1)) 580 assert_equal([1, 2], m(a: 1, b: 2)) 581 assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) } 582 583 def m(a:, **) a end 584 assert_equal(1, m(a: 1)) 585 assert_equal(1, m(a: 1, b: 2)) 586 assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) } 587 588 def m(a:, **k) [a, k] end 589 assert_equal([1, {}], m(a: 1)) 590 assert_equal([1, {b: 2, c: 3}], m(a: 1, b: 2, c: 3)) 591 assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) } 592 593=begin 594 def m(a:, &b) [a, b] end 595 assert_equal([1, nil], m(a: 1)) 596 assert_equal([1, l], m(a: 1, &(l = ->{}))) 597=end 598 599 def m(a: 1, b:) [a, b] end 600 assert_equal([1, 0], m(b: 0)) 601 assert_equal([3, 2], m(b: 2, a: 3)) 602 assert_raise(ArgumentError) { m a: 1 } 603 604 def m(a: def m(a: 1) a end, b:) 605 [a, b] 606 end 607 assert_equal([2, 3], m(a: 2, b: 3)) 608 assert_equal([:m, 1], m(b: 1)) 609 # Note the default value of a: in the original method. 610 assert_equal(1, m()) 611 612 def m(a: 1, b: 2) [a, b] end 613 assert_equal([1, 2], m()) 614 assert_equal([4, 3], m(b: 3, a: 4)) 615 616 def m(a: 1, **) a end 617 assert_equal(1, m()) 618 assert_equal(2, m(a: 2, b: 1)) 619 620 def m(a: 1, **k) [a, k] end 621 assert_equal([1, {b: 2, c: 3}], m(b: 2, c: 3)) 622 623 def m(a:, **) yield end 624 assert_raise(ArgumentError) { m { :blk } } 625 assert_equal :blk, m(a: 1){ :blk } 626 627 def m(a:, **k, &b) [b.call, k] end 628 assert_raise(ArgumentError) { m { :blk } } 629 assert_equal [:blk, {b: 2}], m(a: 1, b: 2){ :blk } 630 631 def m(**k, &b) [k, b] end 632 assert_equal([{ a: 1, b: 2}, nil], m(a: 1, b: 2)) 633 assert_equal :blk, m{ :blk }[1].call 634 635 def m(hsh = {}) hsh end 636 assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2)) 637 assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2)) 638 639 def m(hsh) hsh end 640 assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2)) 641 assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2)) 642 643=begin 644 def m(a, b=1, *c, (*d, (e)), f: 2, g:, h:, **k, &l) 645 [a, b, c, d, e, f, g, h, k, l] 646 end 647 result = m(9, 8, 7, 6, f: 5, g: 4, h: 3, &(l = ->{})) 648 assert_equal([9, 8, [7], [], 6, 5, 4, 3, {}, l], result) 649 650 def m a, b=1, *c, d, e:, f: 2, g:, **k, &l 651 [a, b, c, d, e, f, g, k, l] 652 end 653 result = m(1, 2, e: 3, g: 4, h: 5, i: 6, &(l = ->{})) 654 assert_equal([1, 1, [], 2, 3, 2, 4, { h: 5, i: 6 }, l], result) 655=end 656end 657