1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
require 'test/unit'
class TestVarArgBlock < Test::Unit::TestCase
def blockyield(arg)
yield arg
end
def blockarg(arg, &b)
b.call(arg)
end
def test_vararg_blocks
Proc.new { |*element| assert_equal [["a"]], element }.call( ["a"] )
Proc.new { |*element| assert_equal ["a"], element }.call( "a" )
proc { |*element| assert_equal [["a"]], element }.call( ["a"] )
proc { |*element| assert_equal ["a"], element }.call( "a" )
lambda { |*element| assert_equal [["a"]], element }.call( ["a"] )
lambda { |*element| assert_equal ["a"], element }.call( "a" )
blockyield(["a"]) { |*element| assert_equal [["a"]], element }
blockyield("a") { |*element| assert_equal ["a"], element }
blockyield(["a"], &Proc.new { |*element| assert_equal [["a"]], element })
blockyield("a", &Proc.new { |*element| assert_equal ["a"], element })
blockyield(["a"], &proc { |*element| assert_equal [["a"]], element })
blockyield("a", &proc { |*element| assert_equal ["a"], element })
blockyield(["a"], &lambda { |*element| assert_equal [["a"]], element })
blockyield("a", &lambda { |*element| assert_equal ["a"], element })
blockarg(["a"]) { |*element| assert_equal [["a"]], element }
blockarg("a") { |*element| assert_equal ["a"], element }
blockarg(["a"], &Proc.new { |*element| assert_equal [["a"]], element })
blockarg("a", &Proc.new { |*element| assert_equal ["a"], element })
blockarg(["a"], &proc { |*element| assert_equal [["a"]], element })
blockarg("a", &proc { |*element| assert_equal ["a"], element })
blockarg(["a"], &lambda { |*element| assert_equal [["a"]], element })
blockarg("a", &lambda { |*element| assert_equal ["a"], element })
end
def test_requiredarg_blocks
Proc.new { |element| assert_equal ["a"], element }.call( ["a"] )
Proc.new { |element| assert_equal "a", element }.call( "a" )
proc { |element| assert_equal ["a"], element }.call( ["a"] )
proc { |element| assert_equal "a", element }.call( "a" )
lambda { |element| assert_equal ["a"], element }.call( ["a"] )
lambda { |element| assert_equal "a", element }.call( "a" )
blockyield(["a"]) { |element| assert_equal ["a"], element }
blockyield("a") { |element| assert_equal "a", element }
blockyield(["a"], &Proc.new { |element| assert_equal ["a"], element })
blockyield("a", &Proc.new { |element| assert_equal "a", element })
blockyield(["a"], &proc { |element| assert_equal ["a"], element })
blockyield("a", &proc { |element| assert_equal "a", element })
blockyield(["a"], &lambda { |element| assert_equal ["a"], element })
blockyield("a", &lambda { |element| assert_equal "a", element })
blockarg(["a"]) { |element| assert_equal ["a"], element }
blockarg("a") { |element| assert_equal "a", element }
blockarg(["a"], &Proc.new { |element| assert_equal ["a"], element })
blockarg("a", &Proc.new { |element| assert_equal "a", element })
blockarg(["a"], &proc { |element| assert_equal ["a"], element })
blockarg("a", &proc { |element| assert_equal "a", element })
blockarg(["a"], &lambda { |element| assert_equal ["a"], element })
blockarg("a", &lambda { |element| assert_equal "a", element })
end
def test_requiredargs_blocks
Proc.new { |element, a| assert_equal "a", element }.call( ["a"] )
Proc.new { |element, a| assert_equal "a", element }.call( "a" )
assert_raises(ArgumentError) {
proc { |element, a| assert_equal ["a"], element }.call( ["a"] )
}
assert_raises(ArgumentError) {
proc { |element, a| assert_equal "a", element }.call( "a" )
}
assert_raises(ArgumentError) {
lambda { |element, a| assert_equal ["a"], element }.call( ["a"] )
}
assert_raises(ArgumentError) {
lambda { |element, a| assert_equal "a", element }.call( "a" )
}
blockyield(["a"]) { |element, a| assert_equal "a", element }
blockyield("a") { |element, a| assert_equal "a", element }
blockyield(["a"], &Proc.new { |element, a| assert_equal "a", element })
blockyield("a", &Proc.new { |element, a| assert_equal "a", element })
blockyield(["a"], &proc { |element, a| assert_equal "a", element })
blockyield("a", &proc { |element, a| assert_equal "a", element })
blockyield(["a"], &lambda { |element, a| assert_equal "a", element })
blockyield("a", &lambda { |element, a| assert_equal "a", element })
blockarg(["a"]) { |element, a| assert_equal "a", element }
blockarg("a") { |element, a| assert_equal "a", element }
blockarg(["a"], &Proc.new { |element, a| assert_equal "a", element })
blockarg("a", &Proc.new { |element, a| assert_equal "a", element })
assert_raises(ArgumentError) {
blockarg(["a"], &proc { |element, a| assert_equal ["a"], element })
}
assert_raises(ArgumentError) {
blockarg("a", &proc { |element, a| assert_equal "a", element })
}
assert_raises(ArgumentError) {
blockarg(["a"], &lambda { |element, a| assert_equal ["a"], element })
}
assert_raises(ArgumentError) {
blockarg("a", &lambda { |element, a| assert_equal "a", element })
}
end
def check_all_definemethods(obj)
results = obj.foo1 ["a"]
assert_equal(results[0], results[1])
results = obj.foo2 "a"
assert_equal(results[0], results[1])
results = obj.foo3 ["a"]
assert_equal(results[0], results[1])
results = obj.foo4 "a"
assert_equal(results[0], results[1])
results = obj.foo5 ["a"]
assert_equal(results[0], results[1])
results = obj.foo6 "a"
assert_equal(results[0], results[1])
results = obj.foo7 ["a"]
assert_equal(results[0], results[1])
results = obj.foo8 "a"
assert_equal(results[0], results[1])
results = obj.foo9 ["a"]
assert_equal(results[0], results[1])
results = obj.foo10 "a"
assert_equal(results[0], results[1])
results = obj.foo11 ["a"]
assert_equal(results[0], results[1])
results = obj.foo12 "a"
assert_equal(results[0], results[1])
results = obj.foo13 ["a"]
assert_equal(results[0], results[1])
results = obj.foo14 "a"
assert_equal(results[0], results[1])
end
def check_requiredargs_definemethods(obj)
results = obj.foo1 ["a"]
assert_equal(results[0], results[1])
results = obj.foo2 "a"
assert_equal(results[0], results[1])
assert_raises(ArgumentError) { results = obj.foo3 ["a"] }
assert_raises(ArgumentError) { results = obj.foo4 "a" }
assert_raises(ArgumentError) { results = obj.foo5 ["a"] }
assert_raises(ArgumentError) { results = obj.foo6 "a" }
assert_raises(ArgumentError) { results = obj.foo7 ["a"] }
assert_raises(ArgumentError) { results = obj.foo8 "a" }
assert_raises(ArgumentError) { results = obj.foo9 ["a"] }
assert_raises(ArgumentError) { results = obj.foo10 "a" }
assert_raises(ArgumentError) { results = obj.foo11 ["a"] }
assert_raises(ArgumentError) { results = obj.foo12 "a" }
assert_raises(ArgumentError) { results = obj.foo13 ["a"] }
assert_raises(ArgumentError) { results = obj.foo14 "a" }
end
def test_definemethods
obj = Object.new
class << obj
define_method :foo1, Proc.new { |*element| [[["a"]], element] }
define_method :foo2, Proc.new { |*element| [["a"], element] }
define_method :foo3, proc { |*element| [[["a"]], element] }
define_method :foo4, proc { |*element| [["a"], element] }
define_method :foo5, lambda { |*element| [[["a"]], element] }
define_method :foo6, lambda { |*element| [["a"], element] }
define_method(:foo7) { |*element| [[["a"]], element] }
define_method(:foo8) { |*element| [["a"], element] }
define_method :foo9, &Proc.new { |*element| [[["a"]], element] }
define_method :foo10, &Proc.new { |*element| [["a"], element] }
define_method :foo11, &proc { |*element| [[["a"]], element] }
define_method :foo12, &proc { |*element| [["a"], element] }
define_method :foo13, &lambda { |*element| [[["a"]], element] }
define_method :foo14, &lambda { |*element| [["a"], element] }
end
check_all_definemethods(obj)
class << obj
define_method :foo1, Proc.new { |element| [["a"], element] }
define_method :foo2, Proc.new { |element| ["a", element] }
define_method :foo3, proc { |element| [["a"], element] }
define_method :foo4, proc { |element| ["a", element] }
define_method :foo5, lambda { |element| [["a"], element] }
define_method :foo6, lambda { |element| ["a", element] }
define_method(:foo7) { |element| [["a"], element] }
define_method(:foo8) { |element| ["a", element] }
define_method :foo9, &Proc.new { |element| [["a"], element] }
define_method :foo10, &Proc.new { |element| ["a", element] }
define_method :foo11, &proc { |element| [["a"], element] }
define_method :foo12, &proc { |element| ["a", element] }
define_method :foo13, &lambda { |element| [["a"], element] }
define_method :foo14, &lambda { |element| ["a", element] }
end
check_all_definemethods(obj)
class << obj
define_method :foo1, Proc.new { |element, a| ["a", element] }
define_method :foo2, Proc.new { |element, a| ["a", element] }
define_method :foo3, proc { |element, a| [["a"], element] }
define_method :foo4, proc { |element, a| ["a", element] }
define_method :foo5, lambda { |element, a| [["a"], element] }
define_method :foo6, lambda { |element, a| ["a", element] }
define_method(:foo7) { |element, a| [["a"], element] }
define_method(:foo8) { |element, a| ["a", element] }
define_method :foo9, &Proc.new { |element, a| [["a"], element] }
define_method :foo10, &Proc.new { |element, a| ["a", element] }
define_method :foo11, &proc { |element, a| [["a"], element] }
define_method :foo12, &proc { |element, a| ["a", element] }
define_method :foo13, &lambda { |element, a| [["a"], element] }
define_method :foo14, &lambda { |element, a| ["a", element] }
end
check_requiredargs_definemethods(obj)
end
end
|
