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
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
# frozen_string_literal: false
require 'test/unit'
class TestVariable < Test::Unit::TestCase
class Gods
@@rule = "Uranus"
def ruler0
@@rule
end
def self.ruler1 # <= per method definition style
@@rule
end
class << self # <= multiple method definition style
def ruler2
@@rule
end
end
end
module Olympians
@@rule ="Zeus"
def ruler3
@@rule
end
end
class Titans < Gods
@@rule = "Cronus" # modifies @@rule in Gods
include Olympians
def ruler4
EnvUtil.suppress_warning {
@@rule
}
end
end
def test_setting_class_variable_on_module_through_inheritance
mod = Module.new
mod.class_variable_set(:@@foo, 1)
mod.freeze
c = Class.new { include(mod) }
assert_raise(FrozenError) { c.class_variable_set(:@@foo, 2) }
assert_raise(FrozenError) { c.class_eval("@@foo = 2") }
assert_equal(1, c.class_variable_get(:@@foo))
end
def test_singleton_class_included_class_variable
c = Class.new
c.extend(Olympians)
assert_empty(c.singleton_class.class_variables)
assert_raise(NameError){ c.singleton_class.class_variable_get(:@@rule) }
c.class_variable_set(:@@foo, 1)
assert_equal([:@@foo], c.singleton_class.class_variables)
assert_equal(1, c.singleton_class.class_variable_get(:@@foo))
c = Class.new
c.extend(Olympians)
sc = Class.new(c)
assert_empty(sc.singleton_class.class_variables)
assert_raise(NameError){ sc.singleton_class.class_variable_get(:@@rule) }
c.class_variable_set(:@@foo, 1)
assert_equal([:@@foo], sc.singleton_class.class_variables)
assert_equal(1, sc.singleton_class.class_variable_get(:@@foo))
c = Class.new
o = c.new
o.extend(Olympians)
assert_equal([:@@rule], o.singleton_class.class_variables)
assert_equal("Zeus", o.singleton_class.class_variable_get(:@@rule))
c.class_variable_set(:@@foo, 1)
assert_equal([:@@foo, :@@rule], o.singleton_class.class_variables.sort)
assert_equal(1, o.singleton_class.class_variable_get(:@@foo))
end
class IncludeRefinedModuleClassVariableNoWarning
module Mod
@@_test_include_refined_module_class_variable = true
end
module Mod2
refine Mod do
end
end
include Mod
def t
@@_test_include_refined_module_class_variable
end
end
def test_include_refined_module_class_variable
assert_warning('') do
IncludeRefinedModuleClassVariableNoWarning.new.t
end
end
def test_variable
assert_instance_of(Integer, $$)
# read-only variable
assert_raise(NameError) do
$$ = 5
end
assert_normal_exit("$*=0; $*", "[ruby-dev:36698]")
foobar = "foobar"
$_ = foobar
assert_equal(foobar, $_)
assert_equal("Cronus", Gods.new.ruler0)
assert_equal("Cronus", Gods.ruler1)
assert_equal("Cronus", Gods.ruler2)
assert_equal("Cronus", Titans.ruler1)
assert_equal("Cronus", Titans.ruler2)
atlas = Titans.new
assert_equal("Cronus", atlas.ruler0)
assert_equal("Zeus", atlas.ruler3)
assert_equal("Cronus", atlas.ruler4)
assert_nothing_raised do
class << Gods
defined?(@@rule) && @@rule
end
end
end
def test_local_variables
lvar = 1
assert_instance_of(Symbol, local_variables[0], "[ruby-dev:34008]")
lvar
end
def test_local_variables2
x = 1
proc do |y|
assert_equal([:x, :y], local_variables.sort)
end.call
x
end
def test_local_variables3
x = 1
proc do |y|
1.times do |z|
assert_equal([:x, :y, :z], local_variables.sort)
end
end.call
x
end
def test_shadowing_local_variables
bug9486 = '[ruby-core:60501] [Bug #9486]'
assert_equal([:x, :bug9486], tap {|x| break local_variables}, bug9486)
end
def test_shadowing_block_local_variables
bug9486 = '[ruby-core:60501] [Bug #9486]'
assert_equal([:x, :bug9486], tap {|;x| x = x; break local_variables}, bug9486)
end
def test_global_variables
gv = global_variables
assert_empty(gv.grep(/\A(?!\$)/))
assert_nil($~)
assert_not_include(gv, :$1)
/(\w)(\d)?(.)(.)(.)(.)(.)(.)(.)(.)(\d)?(.)/ =~ "globalglobalglobal"
assert_not_nil($~)
gv = global_variables - gv
assert_include(gv, :$1)
assert_not_include(gv, :$2)
assert_not_include(gv, :$11)
assert_include(gv, :$12)
end
def test_global_variable_0
assert_in_out_err(["-e", "$0='t'*1000;print $0"], "", /\At+\z/, [])
end
def test_global_variable_popped
assert_nothing_raised {
EnvUtil.suppress_warning {
eval("$foo; 1")
}
}
end
def test_constant_popped
assert_nothing_raised {
EnvUtil.suppress_warning {
eval("TestVariable::Gods; 1")
}
}
end
def test_special_constant_ivars
[ true, false, :symbol, "dsym#{rand(9999)}".to_sym, 1, 1.0 ].each do |v|
assert_empty v.instance_variables
msg = "can't modify frozen #{v.class}: #{v.inspect}"
assert_raise_with_message(FrozenError, msg) do
v.instance_variable_set(:@foo, :bar)
end
assert_nil EnvUtil.suppress_warning {v.instance_variable_get(:@foo)}
assert_not_send([v, :instance_variable_defined?, :@foo])
assert_raise_with_message(FrozenError, msg) do
v.remove_instance_variable(:@foo)
end
end
end
class ExIvar < Hash
def initialize
@a = 1
@b = 2
@c = 3
end
def ivars
[@a, @b, @c]
end
end
def test_external_ivars
3.times{
# check inline cache for external ivar access
assert_equal [1, 2, 3], ExIvar.new.ivars
}
end
def test_local_variables_with_kwarg
bug11674 = '[ruby-core:71437] [Bug #11674]'
v = with_kwargs_11(v1:1,v2:2,v3:3,v4:4,v5:5,v6:6,v7:7,v8:8,v9:9,v10:10,v11:11)
assert_equal(%i(v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11), v, bug11674)
end
private
def with_kwargs_11(v1:, v2:, v3:, v4:, v5:, v6:, v7:, v8:, v9:, v10:, v11:)
local_variables
end
end
|
