From 5177dd8ba081dd25bf8ceb0f1c861ea8f83884c3 Mon Sep 17 00:00:00 2001 From: Jeremy Evans Date: Wed, 18 Sep 2019 11:16:00 -0700 Subject: [PATCH] Add and fix some keyword tests Replace [arg=1, args] with [arg, args] so we can actually test the value correctly. Add some missing tests for **h3 when method accepts (**args). Add tests for passing positional hashes to (**args) methods and check for the expected warnings/errors. --- test/ruby/test_keyword.rb | 199 ++++++++++++++++++++++++++++++++++---- 1 file changed, 182 insertions(+), 17 deletions(-) diff --git a/test/ruby/test_keyword.rb b/test/ruby/test_keyword.rb index fa65074d17..a9e2b1f1c3 100644 --- a/test/ruby/test_keyword.rb +++ b/test/ruby/test_keyword.rb @@ -232,7 +232,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.m(**h)) assert_equal(h, c.m(a: 1)) assert_equal(h2, c.m(**h2)) + assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { c.m(h3) } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -259,10 +267,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_warn(/The keyword argument is passed as the last hash parameter.* for `m'/m) do assert_equal([h3, kw], c.m(a: 1, **h2)) end + assert_equal([h, kw], c.m(h)) + assert_equal([h2, kw], c.m(h2)) + assert_equal([h3, kw], c.m(h3)) c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.m(**{})) assert_equal([1, kw], c.m(**kw)) @@ -271,6 +282,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal([1, h2], c.m(**h2)) assert_equal([1, h3], c.m(**h3)) assert_equal([1, h3], c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal([1, h], c.m(h)) + end + assert_equal([h2, kw], c.m(h2)) + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_equal([h2, h], c.m(h3)) + end end def test_implicit_super_kwsplat @@ -338,7 +356,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.m(**h)) assert_equal(h, c.m(a: 1)) assert_equal(h2, c.m(**h2)) + assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { c.m(h3) } + end sc.class_eval do remove_method(:m) @@ -371,7 +397,7 @@ class TestKeywordArguments < Test::Unit::TestCase sc.class_eval do remove_method(:m) def m(arg=1, **args) - [arg=1, args] + [arg, args] end end assert_equal([1, kw], c.m(**{})) @@ -448,7 +474,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.m(**h)) assert_equal(h, c.m(a: 1)) assert_equal(h2, c.m(**h2)) + assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { c.m(h3) } + end sc.class_eval do remove_method(:m) @@ -481,7 +515,7 @@ class TestKeywordArguments < Test::Unit::TestCase sc.class_eval do remove_method(:m) def m(arg=1, **args) - [arg=1, args] + [arg, args] end end assert_equal([1, kw], c.m(**{})) @@ -528,6 +562,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, f[**h2]) assert_equal(h3, f[**h3]) assert_equal(h3, f[a: 1, **h2]) + assert_warn(/The last argument is used as the keyword parameter.*for `\[\]'/m) do + assert_equal(h, f[h]) + end + assert_raise(ArgumentError) { f[h2] } + assert_warn(/The last argument is split into positional and keyword parameters.*for `\[\]'/m) do + assert_raise(ArgumentError) { f[h3] } + end f = ->(a, **x) { [a,x] } assert_warn(/The keyword argument is passed as the last hash parameter.* for `\[\]'/m) do @@ -600,6 +641,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, f[**h2]) assert_equal(h3, f[**h3]) assert_equal(h3, f[a: 1, **h2]) + assert_warn(/The last argument is used as the keyword parameter.*for method/m) do + assert_equal(h, f[h]) + end + assert_raise(ArgumentError) { f[h2] } + assert_warn(/The last argument is split into positional and keyword parameters.*for method/m) do + assert_raise(ArgumentError) { f[h3] } + end f = ->(a, **x) { [a,x] } f = f.method(:call) @@ -702,6 +750,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, c[**h2].args) assert_equal(h3, c[**h3].args) assert_equal(h3, c[a: 1, **h2].args) + assert_warn(/The last argument is used as the keyword parameter.*for `initialize'/m) do + assert_equal(h, c[h].args) + end + assert_raise(ArgumentError) { c[h2].args } + assert_warn(/The last argument is split into positional and keyword parameters.*for `initialize'/m) do + assert_raise(ArgumentError) { c[h3].args } + end c = Class.new(sc) do def initialize(arg, **args) @@ -732,7 +787,7 @@ class TestKeywordArguments < Test::Unit::TestCase c = Class.new(sc) do def initialize(arg=1, **args) - @args = [arg=1, args] + @args = [arg, args] end end assert_equal([1, kw], c[**{}].args) @@ -807,6 +862,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, c[**h2].args) assert_equal(h3, c[**h3].args) assert_equal(h3, c[a: 1, **h2].args) + assert_warn(/The last argument is used as the keyword parameter.*for `initialize'/m) do + assert_equal(h, c[h].args) + end + assert_raise(ArgumentError) { c[h2].args } + assert_warn(/The last argument is split into positional and keyword parameters.*for `initialize'/m) do + assert_raise(ArgumentError) { c[h3].args } + end c = Class.new(sc) do def initialize(arg, **args) @@ -837,7 +899,7 @@ class TestKeywordArguments < Test::Unit::TestCase c = Class.new(sc) do def initialize(arg=1, **args) - @args = [arg=1, args] + @args = [arg, args] end end.method(:new) assert_equal([1, kw], c[**{}].args) @@ -904,6 +966,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, c.method(:m)[**h2]) assert_equal(h3, c.method(:m)[**h3]) assert_equal(h3, c.method(:m)[a: 1, **h2]) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, c.method(:m)[h]) + end + assert_raise(ArgumentError) { c.method(:m)[h2] } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { c.method(:m)[h3] } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -933,7 +1002,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.method(:m)[**{}]) assert_equal([1, kw], c.method(:m)[**kw]) @@ -1000,6 +1069,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, sc.instance_method(:m).bind_call(c, **h2)) assert_equal(h3, sc.instance_method(:m).bind_call(c, **h3)) assert_equal(h3, sc.instance_method(:m).bind_call(c, a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, sc.instance_method(:m).bind_call(c, h)) + end + assert_raise(ArgumentError) { sc.instance_method(:m).bind_call(c, h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { sc.instance_method(:m).bind_call(c, h3) } + end sc.remove_method(:m) def c.m(arg, **args) @@ -1029,7 +1105,7 @@ class TestKeywordArguments < Test::Unit::TestCase sc.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], sc.instance_method(:m).bind_call(c, **{})) assert_equal([1, kw], sc.instance_method(:m).bind_call(c, **kw)) @@ -1093,7 +1169,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.send(:m, **h)) assert_equal(h, c.send(:m, a: 1)) assert_equal(h2, c.send(:m, **h2)) + assert_equal(h3, c.send(:m, **h3)) assert_equal(h3, c.send(:m, a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, c.send(:m, h)) + end + assert_raise(ArgumentError) { c.send(:m, h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { c.send(:m, h3) } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -1123,7 +1207,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.send(:m, **{})) assert_equal([1, kw], c.send(:m, **kw)) @@ -1191,7 +1275,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, m.call(:m, **h)) assert_equal(h, m.call(:m, a: 1)) assert_equal(h2, m.call(:m, **h2)) + assert_equal(h3, m.call(:m, **h3)) assert_equal(h3, m.call(:m, a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, m.call(:m, h)) + end + assert_raise(ArgumentError) { m.call(:m, h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { m.call(:m, h3) } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -1222,7 +1314,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end m = c.method(:send) assert_equal([1, kw], m.call(:m, **{})) @@ -1289,6 +1381,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, :m.to_proc.call(c, **h2)) assert_equal(h3, :m.to_proc.call(c, **h3)) assert_equal(h3, :m.to_proc.call(c, a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, :m.to_proc.call(c, h)) + end + assert_raise(ArgumentError) { :m.to_proc.call(c, h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { :m.to_proc.call(c, h3) } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -1318,7 +1417,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], :m.to_proc.call(c, **{})) assert_equal([1, kw], :m.to_proc.call(c, **kw)) @@ -1385,6 +1484,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, m.call(c, **h2)) assert_equal(h3, m.call(c, **h3)) assert_equal(h3, m.call(c, a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, m.call(c, h)) + end + assert_raise(ArgumentError) { m.call(c, h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { m.call(c, h3) } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -1414,7 +1520,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], m.call(c, **{})) assert_equal([1, kw], m.call(c, **kw)) @@ -1478,7 +1584,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.m(**h)) assert_equal(h, c.m(a: 1)) assert_equal(h2, c.m(**h2)) + assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `method_missing'/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `method_missing'/m) do + assert_raise(ArgumentError) { c.m(h3) } + end c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg, **args) @@ -1508,7 +1622,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.m(**{})) assert_equal([1, kw], c.m(**kw)) @@ -1576,7 +1690,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.m(**h)) assert_equal(h, c.m(a: 1)) assert_equal(h2, c.m(**h2)) + assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `m'/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `m'/m) do + assert_raise(ArgumentError) { c.m(h3) } + end c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg, **args) @@ -1606,7 +1728,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.m(**{})) assert_equal([1, kw], c.m(**kw)) @@ -1671,7 +1793,15 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h, c.m(**h)) assert_equal(h, c.m(a: 1)) assert_equal(h2, c.m(**h2)) + assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter.*for `method_missing'/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `method_missing'/m) do + assert_raise(ArgumentError) { c.m(h3) } + end c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg, **args) @@ -1701,7 +1831,7 @@ class TestKeywordArguments < Test::Unit::TestCase c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.m(**{})) assert_equal([1, kw], c.m(**kw)) @@ -1769,6 +1899,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, c.m(**h2)) assert_equal(h3, c.m(**h3)) assert_equal(h3, c.m(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter/m) do + assert_equal(h, c.m(h)) + end + assert_raise(ArgumentError) { c.m(h2) } + assert_warn(/The last argument is split into positional and keyword parameters/m) do + assert_raise(ArgumentError) { c.m(h3) } + end c = Object.new class << c @@ -1892,6 +2029,13 @@ class TestKeywordArguments < Test::Unit::TestCase assert_equal(h2, m.call(**h2)) assert_equal(h3, m.call(**h3)) assert_equal(h3, m.call(a: 1, **h2)) + assert_warn(/The last argument is used as the keyword parameter/m) do + assert_equal(h, m.call(h)) + end + assert_raise(ArgumentError) { m.call(h2) } + assert_warn(/The last argument is split into positional and keyword parameters/m) do + assert_raise(ArgumentError) { m.call(h3) } + end c = Object.new class << c @@ -2802,6 +2946,13 @@ class TestKeywordArgumentsSymProcRefinements < Test::Unit::TestCase assert_equal(h2, c.call(**h2, &:m)) assert_equal(h3, c.call(**h3, &:m)) assert_equal(h3, c.call(a: 1, **h2, &:m)) + assert_warn(/The last argument is used as the keyword parameter.*for `call'/m) do + assert_equal(h, c.call(h, &:m)) + end + assert_raise(ArgumentError) { c.call(h2, &:m) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `call'/m) do + assert_raise(ArgumentError) { c.call(h3, &:m) } + end c.singleton_class.remove_method(:m) def c.m(arg, **args) @@ -2831,7 +2982,7 @@ class TestKeywordArgumentsSymProcRefinements < Test::Unit::TestCase c.singleton_class.remove_method(:m) def c.m(arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.call(**{}, &:m)) assert_equal([1, kw], c.call(**kw, &:m)) @@ -2898,6 +3049,13 @@ class TestKeywordArgumentsSymProcRefinements < Test::Unit::TestCase assert_equal(h2, c.call(**h2, &:m)) assert_equal(h3, c.call(**h3, &:m)) assert_equal(h3, c.call(a: 1, **h2, &:m)) + assert_warn(/The last argument is used as the keyword parameter.*for `call'/m) do + assert_equal(h, c.call(h, &:m2)) + end + assert_raise(ArgumentError) { c.call(h2, &:m2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `call'/m) do + assert_raise(ArgumentError) { c.call(h3, &:m2) } + end c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg, **args) @@ -2927,7 +3085,7 @@ class TestKeywordArgumentsSymProcRefinements < Test::Unit::TestCase c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.call(**{}, &:m)) assert_equal([1, kw], c.call(**kw, &:m)) @@ -2994,6 +3152,13 @@ class TestKeywordArgumentsSymProcRefinements < Test::Unit::TestCase assert_equal(h2, c.call(**h2, &:m2)) assert_equal(h3, c.call(**h3, &:m2)) assert_equal(h3, c.call(a: 1, **h2, &:m2)) + assert_warn(/The last argument is used as the keyword parameter.*for `call'/m) do + assert_equal(h, c.call(h, &:m2)) + end + assert_raise(ArgumentError) { c.call(h2, &:m2) } + assert_warn(/The last argument is split into positional and keyword parameters.*for `call'/m) do + assert_raise(ArgumentError) { c.call(h3, &:m2) } + end c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg, **args) @@ -3023,7 +3188,7 @@ class TestKeywordArgumentsSymProcRefinements < Test::Unit::TestCase c.singleton_class.remove_method(:method_missing) def c.method_missing(_, arg=1, **args) - [arg=1, args] + [arg, args] end assert_equal([1, kw], c.call(**{}, &:m2)) assert_equal([1, kw], c.call(**kw, &:m2))