From a0a2c144b8b078cea668a703e2308ea64d4eb161 Mon Sep 17 00:00:00 2001
From: mame <mame@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>
Date: Mon, 26 Dec 2011 14:20:09 +0000
Subject: * vm_core.h (struct rb_iseq_struct), compile.c (iseq_set_arguments,
 iseq_compile_each), vm_insnhelper.c (vm_callee_setup_arg_complex): implement
 keyword arguments. See [ruby-core:40290] The feature is promised to be
 included in 2.0, but the detail spec is still under discussion; this commit
 is a springboard for further discussion. Please try it and give us feedback.
 This commit includes fixes for some problems reported by Benoit Daloze
 <eregontp AT gmail.com> [ruby-core:40518] and Marc-Andre Lafortune
 <ruby-core-mailing-list AT marc-andre.ca> [ruby-core:41772].

* iseq.c (iseq_free, prepare_iseq_build): bookkeeping.

* test/ruby/test_keyword.rb: add tests for keyword arguments.

* test/ripper/dummyparser.rb (class DummyParser): temporal fix for
  ripper test.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@34136 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
---
 test/ruby/test_keyword.rb | 105 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 test/ruby/test_keyword.rb

(limited to 'test/ruby/test_keyword.rb')

diff --git a/test/ruby/test_keyword.rb b/test/ruby/test_keyword.rb
new file mode 100644
index 0000000000..27edc6b8fd
--- /dev/null
+++ b/test/ruby/test_keyword.rb
@@ -0,0 +1,105 @@
+require 'test/unit'
+
+class TestKeywordArguments < Test::Unit::TestCase
+  def f1(str: "foo", num: 424242)
+    [str, num]
+  end
+
+  def test_f1
+    assert_equal(["foo", 424242], f1)
+    assert_equal(["bar", 424242], f1(str: "bar"))
+    assert_equal(["foo", 111111], f1(num: 111111))
+    assert_equal(["bar", 111111], f1(str: "bar", num: 111111))
+    assert_raise(ArgumentError) { f1(str: "bar", check: true) }
+    assert_raise(ArgumentError) { f1("string") }
+  end
+
+
+  def f2(x, str: "foo", num: 424242)
+    [x, str, num]
+  end
+
+  def test_f2
+    assert_equal([:xyz, "foo", 424242], f2(:xyz))
+  end
+
+
+  def f3(str: "foo", num: 424242, **h)
+    [str, num, h]
+  end
+
+  def test_f3
+    assert_equal(["foo", 424242, {}], f3)
+    assert_equal(["bar", 424242, {}], f3(str: "bar"))
+    assert_equal(["foo", 111111, {}], f3(num: 111111))
+    assert_equal(["bar", 111111, {}], f3(str: "bar", num: 111111))
+    assert_equal(["bar", 424242, {:check=>true}], f3(str: "bar", check: true))
+    assert_raise(ArgumentError) { f3("string") }
+  end
+
+
+  define_method(:f4) {|str: "foo", num: 424242| [str, num] }
+
+  def test_f4
+    assert_equal(["foo", 424242], f4)
+    assert_equal(["bar", 424242], f4(str: "bar"))
+    assert_equal(["foo", 111111], f4(num: 111111))
+    assert_equal(["bar", 111111], f4(str: "bar", num: 111111))
+    assert_raise(ArgumentError) { f4(str: "bar", check: true) }
+    assert_raise(ArgumentError) { f4("string") }
+  end
+
+
+  define_method(:f5) {|str: "foo", num: 424242, **h| [str, num, h] }
+
+  def test_f5
+    assert_equal(["foo", 424242, {}], f5)
+    assert_equal(["bar", 424242, {}], f5(str: "bar"))
+    assert_equal(["foo", 111111, {}], f5(num: 111111))
+    assert_equal(["bar", 111111, {}], f5(str: "bar", num: 111111))
+    assert_equal(["bar", 424242, {:check=>true}], f5(str: "bar", check: true))
+    assert_raise(ArgumentError) { f5("string") }
+  end
+
+
+  def f6(str: "foo", num: 424242, **h, &blk)
+    [str, num, h, blk]
+  end
+
+  def test_f6 # [ruby-core:40518]
+    assert_equal(["foo", 424242, {}, nil], f6)
+    assert_equal(["bar", 424242, {}, nil], f6(str: "bar"))
+    assert_equal(["foo", 111111, {}, nil], f6(num: 111111))
+    assert_equal(["bar", 111111, {}, nil], f6(str: "bar", num: 111111))
+    assert_equal(["bar", 424242, {:check=>true}, nil], f6(str: "bar", check: true))
+    a = f6 {|x| x + 42 }
+    assert_equal(["foo", 424242, {}], a[0, 3])
+    assert_equal(43, a.last.call(1))
+  end
+
+  def f7(*r, str: "foo", num: 424242, **h)
+    [r, str, num, h]
+  end
+
+  def test_f7 # [ruby-core:41772]
+    assert_equal([[], "foo", 424242, {}], f7)
+    assert_equal([[], "bar", 424242, {}], f7(str: "bar"))
+    assert_equal([[], "foo", 111111, {}], f7(num: 111111))
+    assert_equal([[], "bar", 111111, {}], f7(str: "bar", num: 111111))
+    assert_equal([[1], "foo", 424242, {}], f7(1))
+    assert_equal([[1, 2], "foo", 424242, {}], f7(1, 2))
+    assert_equal([[1, 2, 3], "foo", 424242, {}], f7(1, 2, 3))
+    assert_equal([[1], "bar", 424242, {}], f7(1, str: "bar"))
+    assert_equal([[1, 2], "bar", 424242, {}], f7(1, 2, str: "bar"))
+    assert_equal([[1, 2, 3], "bar", 424242, {}], f7(1, 2, 3, str: "bar"))
+  end
+
+
+  def test_lambda
+    f = ->(str: "foo", num: 424242) { [str, num] }
+    assert_equal(["foo", 424242], f[])
+    assert_equal(["bar", 424242], f[str: "bar"])
+    assert_equal(["foo", 111111], f[num: 111111])
+    assert_equal(["bar", 111111], f[str: "bar", num: 111111])
+  end
+end
-- 
cgit v1.2.3