summaryrefslogtreecommitdiff
path: root/test/ruby/test_defined.rb
blob: 3324a09afecd585eecdd19cc4289f8ef3d3989a0 (plain)
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
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
# frozen_string_literal: false
require 'test/unit'

class TestDefined < Test::Unit::TestCase
  class Foo
    def foo
      p :foo
    end
    protected :foo
    def bar(f)
      yield(defined?(self.foo))
      yield(defined?(f.foo))
    end
    def baz(f)
    end
    attr_accessor :attr
    def attrasgn_test
      yield(defined?(self.attr = 1))
    end
  end

  def defined_test
    return !defined?(yield)
  end

  def test_defined_global_variable
    $x = nil

    assert(defined?($x))		# global variable
    assert_equal('global-variable', defined?($x))# returns description
  end

  def test_defined_local_variable
    assert_nil(defined?(foo))		# undefined
    foo=5
    assert(defined?(foo))		# local variable
  end

  def test_defined_constant
    assert(defined?(Array))		# constant
    assert(defined?(::Array))		# toplevel constant
    assert(defined?(File::Constants))	# nested constant
  end

  def test_defined_public_method
    assert(defined?(Object.new))	# method
    assert(defined?(Object::new))	# method
  end

  def test_defined_private_method
    assert(!defined?(Object.print))	# private method
  end

  def test_defined_operator
    assert(defined?(1 == 2))		# operator expression
  end

  def test_defined_protected_method
    f = Foo.new
    assert_nil(defined?(f.foo))         # protected method
    f.bar(f) { |v| assert(v) }
    f.bar(Class.new(Foo).new) { |v| assert(v, "inherited protected method") }
  end

  def test_defined_undefined_method
    f = Foo.new
    assert_nil(defined?(f.quux))        # undefined method
  end

  def test_defined_undefined_argument
    f = Foo.new
    assert_nil(defined?(f.baz(x)))      # undefined argument
    x = 0
    assert(defined?(f.baz(x)))
    assert_nil(defined?(f.quux(x)))
    assert(defined?(print(x)))
    assert_nil(defined?(quux(x)))
  end

  def test_defined_attrasgn
    f = Foo.new
    assert(defined?(f.attr = 1))
    f.attrasgn_test { |v| assert(v) }
  end

  def test_defined_undef
    x = Object.new
    def x.foo; end
    assert(defined?(x.foo))
    x.instance_eval {undef :foo}
    assert(!defined?(x.foo), "undefed method should not be defined?")
  end

  def test_defined_yield
    assert(defined_test)		# not iterator
    assert(!defined_test{})	        # called as iterator
  end

  def test_defined_matchdata
    /a/ =~ ''
    assert_equal nil, defined?($&)
    assert_equal nil, defined?($`)
    assert_equal nil, defined?($')
    assert_equal nil, defined?($+)
    assert_equal nil, defined?($1)
    assert_equal nil, defined?($2)
    /a/ =~ 'a'
    assert_equal 'global-variable', defined?($&)
    assert_equal 'global-variable', defined?($`)
    assert_equal 'global-variable', defined?($') # '
    assert_equal nil, defined?($+)
    assert_equal nil, defined?($1)
    assert_equal nil, defined?($2)
    /(a)/ =~ 'a'
    assert_equal 'global-variable', defined?($&)
    assert_equal 'global-variable', defined?($`)
    assert_equal 'global-variable', defined?($') # '
    assert_equal 'global-variable', defined?($+)
    assert_equal 'global-variable', defined?($1)
    assert_equal nil, defined?($2)
    /(a)b/ =~ 'ab'
    assert_equal 'global-variable', defined?($&)
    assert_equal 'global-variable', defined?($`)
    assert_equal 'global-variable', defined?($') # '
    assert_equal 'global-variable', defined?($+)
    assert_equal 'global-variable', defined?($1)
    assert_equal nil, defined?($2)
  end

  def test_defined_literal
    assert_equal("nil", defined?(nil))
    assert_equal("true", defined?(true))
    assert_equal("false", defined?(false))
    assert_equal("expression", defined?(1))
  end

  def test_defined_method
    self_ = self
    assert_equal("method", defined?(test_defined_method))
    assert_equal("method", defined?(self.test_defined_method))
    assert_equal("method", defined?(self_.test_defined_method))

    assert_equal(nil, defined?(1.test_defined_method))
    assert_equal("method", defined?(1.to_i))
    assert_equal(nil, defined?(1.to_i.test_defined_method))
    assert_equal(nil, defined?(1.test_defined_method.to_i))

    assert_equal("method", defined?("x".reverse))
    assert_equal("method", defined?("x".reverse(1)))
    assert_equal("method", defined?("x".reverse.reverse))
    assert_equal(nil, defined?("x".reverse(1).reverse))

    assert_equal("method", defined?(1.to_i(10)))
    assert_equal("method", defined?(1.to_i("x")))
    assert_equal(nil, defined?(1.to_i("x").undefined))
    assert_equal(nil, defined?(1.to_i(undefined).to_i))
    assert_equal(nil, defined?(1.to_i("x").undefined.to_i))
    assert_equal(nil, defined?(1.to_i(undefined).to_i.to_i))
  end

  def test_defined_method_single_call
    times_called = 0
    define_singleton_method(:t) do
      times_called += 1
      self
    end
    assert_equal("method", defined?(t))
    assert_equal(0, times_called)

    assert_equal("method", defined?(t.t))
    assert_equal(1, times_called)

    times_called = 0
    assert_equal("method", defined?(t.t.t))
    assert_equal(2, times_called)

    times_called = 0
    assert_equal("method", defined?(t.t.t.t))
    assert_equal(3, times_called)

    times_called = 0
    assert_equal("method", defined?(t.t.t.t.t))
    assert_equal(4, times_called)
  end

  def test_defined_empty_paren_expr
    bug8224 = '[ruby-core:54024] [Bug #8224]'
    (1..3).each do |level|
      expr = "("*level+")"*level
      assert_equal("nil", eval("defined? #{expr}"), "#{bug8224} defined? #{expr}")
      assert_equal("nil", eval("defined?(#{expr})"), "#{bug8224} defined?(#{expr})")
    end
  end

  def test_defined_empty_paren_arg
    assert_nil(defined?(p () + 1))
  end

  def test_defined_impl_specific
    feature7035 = '[ruby-core:47558]' # not spec
    assert_predicate(defined?(Foo), :frozen?, feature7035)
    assert_same(defined?(Foo), defined?(Array), feature7035)
  end

  class TestAutoloadedSuperclass
    autoload :A, "a"
  end

  class TestAutoloadedSubclass < TestAutoloadedSuperclass
    def a?
      defined?(A)
    end
  end

  def test_autoloaded_subclass
    bug = "[ruby-core:35509]"

    x = TestAutoloadedSuperclass.new
    class << x
      def a?; defined?(A); end
    end
    assert_equal("constant", x.a?, bug)

    assert_equal("constant", TestAutoloadedSubclass.new.a?, bug)
  end

  class TestAutoloadedNoload
    autoload :A, "a"
    def a?
      defined?(A)
    end
    def b?
      defined?(A::B)
    end
  end

  def test_autoloaded_noload
    loaded = $".dup
    $".clear
    loadpath = $:.dup
    $:.clear
    x = TestAutoloadedNoload.new
    assert_equal("constant", x.a?)
    assert_nil(x.b?)
    assert_equal([], $")
  ensure
    $".replace(loaded)
    $:.replace(loadpath)
  end

  def test_exception
    bug5786 = '[ruby-dev:45021]'
    assert_nil(defined?(raise("[Bug#5786]")::A), bug5786)
  end

  def test_define_method
    bug6644 = '[ruby-core:45831]'
    a = Class.new do
      def self.def_f!;
        singleton_class.send(:define_method, :f) { defined? super }
      end
    end
    aa = Class.new(a)
    a.def_f!
    assert_nil(a.f)
    assert_nil(aa.f)
    aa.def_f!
    assert_equal("super", aa.f, bug6644)
    assert_nil(a.f, bug6644)
  end

  def test_super_in_included_method
    c0 = Class.new do
      def m
      end
    end
    m1 = Module.new do
      def m
        defined?(super)
      end
    end
    c = Class.new(c0) do include m1
      def m
        super
      end
    end
    assert_equal("super", c.new.m)
  end

  def test_super_in_block
    bug8367 = '[ruby-core:54769] [Bug #8367]'
    c = Class.new do
      def x; end
    end

    m = Module.new do
      def b; yield; end
      def x; b {return defined?(super)}; end
    end

    o = c.new
    o.extend(m)
    assert_equal("super", o.x, bug8367)
  end

  def test_super_toplevel
    assert_separately([], "assert_nil(defined?(super))")
  end

  def test_respond_to
    obj = "#{self.class.name}##{__method__}"
    class << obj
      def respond_to?(mid)
        true
      end
    end
    assert_warn(/deprecated method signature.*\n.*respond_to\? is defined here/) do
      Warning[:deprecated] = true
      defined?(obj.foo)
    end
    assert_warn('') do
      Warning[:deprecated] = false
      defined?(obj.foo)
    end
  end

  class ExampleRespondToMissing
    attr_reader :called

    def initialize
      @called = false
    end

    def respond_to_missing? *args
      @called = true
      false
    end

    def existing_method
    end

    def func_defined_existing_func
      defined?(existing_method())
    end

    def func_defined_non_existing_func
      defined?(non_existing_method())
    end
  end

  def test_method_by_respond_to_missing
    bug_11211 = '[Bug #11211]'
    obj = ExampleRespondToMissing.new
    assert_equal("method", defined?(obj.existing_method), bug_11211)
    assert_equal(false, obj.called, bug_11211)
    assert_equal(nil, defined?(obj.non_existing_method), bug_11211)
    assert_equal(true, obj.called, bug_11211)

    bug_11212 = '[Bug #11212]'
    obj = ExampleRespondToMissing.new
    assert_equal("method", obj.func_defined_existing_func, bug_11212)
    assert_equal(false, obj.called, bug_11212)
    assert_equal(nil, obj.func_defined_non_existing_func, bug_11212)
    assert_equal(true, obj.called, bug_11212)
  end

  def test_top_level_constant_not_defined
    assert_nil(defined?(TestDefined::Object))
  end

  class RefinedClass
  end

  module RefiningModule
    refine RefinedClass do
      def pub
      end

      private

      def priv
      end
    end

    def self.call_without_using(x = RefinedClass.new)
      defined?(x.pub)
    end

    def self.vcall_without_using(x = RefinedClass.new)
      x.instance_eval {defined?(priv)}
    end

    using self

    def self.call_with_using(x = RefinedClass.new)
      defined?(x.pub)
    end

    def self.vcall_with_using(x = RefinedClass.new)
      x.instance_eval {defined?(priv)}
    end
  end

  def test_defined_refined_call_without_using
    assert(!RefiningModule.call_without_using, "refined public method without using")
  end

  def test_defined_refined_vcall_without_using
    assert(!RefiningModule.vcall_without_using, "refined private method without using")
  end

  def test_defined_refined_call_with_using
    assert(RefiningModule.call_with_using, "refined public method with using")
  end

  def test_defined_refined_vcall_with_using
    assert(RefiningModule.vcall_with_using, "refined private method with using")
  end
end