1 files changed, 10 insertions, 29 deletions

diff --git a/test/t/syntax.rb b/test/t/syntax.rb
index 515c8f361..a89432b68 100644
--- a/test/t/syntax.rb
+++ b/test/t/syntax.rb
@@ -552,8 +552,7 @@ assert 'keyword arguments' do
   assert_raise(ArgumentError) { m }
   assert_raise(ArgumentError) { m 'a'  => 1, a: 1 }
   h = { a: 1 }
-  assert_equal 1, m(h)
-  assert_equal({ a: 1 }, h)
+  assert_equal 1, m(**h)
 
   def m(a: 1) a end
   assert_equal 1, m
@@ -568,23 +567,23 @@ assert 'keyword arguments' do
   def m(a, **) a end
   assert_equal 1, m(1)
   assert_equal 1, m(1, a: 2, b: 3)
-  assert_equal({ 'a' => 1, b: 2 }, m('a' => 1, b: 2))
+  assert_raise(ArgumentError) { m('a' => 1, b: 2) }
 
   def m(a, **k) [a, k] end
   assert_equal [1, {}], m(1)
   assert_equal [1, {a: 2, b: 3}], m(1, a: 2, b: 3)
-  assert_equal [{'a' => 1, b: 2}, {}], m('a' => 1, b: 2)
+  assert_raise(ArgumentError) { m('a' => 1, b: 2) }
 
   def m(a=1, **) a end
   assert_equal 1, m
   assert_equal 2, m(2, a: 1, b: 0)
-  assert_raise(ArgumentError) { m('a' => 1, a: 2) }
 
   def m(a=1, **k) [a, k] end
   assert_equal [1, {}], m
   assert_equal [1, {a: 1}], m(a: 1)
   assert_equal [2, {a: 1, b: 2}], m(2, a: 1, b: 2)
-  assert_equal [{a: 1}, {b: 2}], m({a: 1}, {b: 2})
+  assert_equal [{a: 1}, {b: 2}], m({a: 1}, b: 2)
+  assert_raise(ArgumentError) { m({a: 1}, {b: 2}) }
 
   def m(*, a:) a end
   assert_equal 1, m(a: 1)
@@ -609,34 +608,27 @@ assert 'keyword arguments' do
   def m(*a, **) a end
   assert_equal [], m()
   assert_equal [1, 2, 3], m(1, 2, 3, a: 4, b: 5)
-  assert_raise(ArgumentError) { m("a" => 1, a: 1) }
   assert_equal [1], m(1, **{a: 2})
 
   def m(*, **k) k end
   assert_equal({}, m())
   assert_equal({a: 4, b: 5}, m(1, 2, 3, a: 4, b: 5))
-  assert_raise(ArgumentError) { m("a" => 1, a: 1) }
 
   def m(a = nil, b = nil, **k) [a, k] end
   assert_equal [nil, {}], m()
   assert_equal([nil, {a: 1}], m(a: 1))
-  assert_raise(ArgumentError) { m("a" => 1, a: 1) }
   assert_equal([{"a" => 1}, {a: 1}], m({ "a" => 1 }, a: 1))
   assert_equal([{a: 1}, {}], m({a: 1}, {}))
-  assert_equal([nil, {}], m({}))
+  assert_equal([{}, {}], m({}))
 
   def m(*a, **k) [a, k] end
   assert_equal([[], {}], m())
   assert_equal([[1], {}], m(1))
   assert_equal([[], {a: 1, b: 2}], m(a: 1, b: 2))
   assert_equal([[1, 2, 3], {a: 2}], m(1, 2, 3, a: 2))
-  assert_raise(ArgumentError) { m("a" => 1, a: 1) }
-  assert_raise(ArgumentError) { m("a" => 1) }
   assert_equal([[], {a: 1}], m(a: 1))
-  assert_raise(ArgumentError) { m("a" => 1, a: 1) }
   assert_equal([[{"a" => 1}], {a: 1}], m({ "a" => 1 }, a: 1))
-  assert_equal([[{a: 1}], {}], m({a: 1}, {}))
-  assert_raise(ArgumentError) { m({a: 1}, {"a" => 1}) }
+  assert_equal([[{a: 1}, {}], {}], m({a: 1}, {}))
 
   def m(a:, b:) [a, b] end
   assert_equal([1, 2], m(a: 1, b: 2))
@@ -645,23 +637,21 @@ assert 'keyword arguments' do
   def m(a:, b: 1) [a, b] end
   assert_equal([1, 1], m(a: 1))
   assert_equal([1, 2], m(a: 1, b: 2))
+  assert_raise(ArgumentError) { m(b: 1) }
   assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 
   def m(a:, **) a end
   assert_equal(1, m(a: 1))
   assert_equal(1, m(a: 1, b: 2))
-  assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 
   def m(a:, **k) [a, k] end
   assert_equal([1, {}], m(a: 1))
   assert_equal([1, {b: 2, c: 3}], m(a: 1, b: 2, c: 3))
-  assert_raise(ArgumentError) { m("a" => 1, a: 1, b: 2) }
 
-=begin
   def m(a:, &b) [a, b] end
   assert_equal([1, nil], m(a: 1))
-  assert_equal([1, l], m(a: 1, &(l = ->{})))
-=end
+  result = m(a: 1, &(l = ->{}))
+  assert_equal([1, l], result)
 
   def m(a: 1, b:) [a, b] end
   assert_equal([1, 0], m(b: 0))
@@ -699,21 +689,12 @@ assert 'keyword arguments' do
   assert_equal([{ a: 1, b: 2}, nil], m(a: 1, b: 2))
   assert_equal :blk, m{ :blk }[1].call
 
-  def m(hsh = {}) hsh end
-  assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2))
-  assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2))
-
-  def m(hsh) hsh end
-  assert_equal({ a: 1, b: 2 }, m(a: 1, b: 2))
-  assert_equal({ a: 1, 'b' => 2 }, m(a: 1, 'b' => 2))
-
 =begin
   def m(a, b=1, *c, (*d, (e)), f: 2, g:, h:, **k, &l)
     [a, b, c, d, e, f, g, h, k, l]
   end
   result = m(9, 8, 7, 6, f: 5, g: 4, h: 3, &(l = ->{}))
   assert_equal([9, 8, [7], [], 6, 5, 4, 3, {}, l], result)
-
   def m a, b=1, *c, d, e:, f: 2, g:, **k, &l
     [a, b, c, d, e, f, g, k, l]
   end