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
|
require 'test/unit'
require 'delegate'
class TestDelegateClass < Test::Unit::TestCase
module M
attr_reader :m
end
def test_extend
obj = DelegateClass(Array).new([])
obj.instance_eval { @m = :m }
obj.extend M
assert_equal(:m, obj.m, "[ruby-dev:33116]")
end
def test_systemcallerror_eq
e = SystemCallError.new(0)
assert((SimpleDelegator.new(e) == e) == (e == SimpleDelegator.new(e)), "[ruby-dev:34808]")
end
class Myclass < DelegateClass(Array);end
def test_delegateclass_class
myclass=Myclass.new([])
assert_equal(Myclass,myclass.class)
assert_equal(Myclass,myclass.dup.class,'[ruby-dev:40313]')
assert_equal(Myclass,myclass.clone.class,'[ruby-dev:40313]')
end
def test_simpledelegator_class
simple=SimpleDelegator.new([])
assert_equal(SimpleDelegator,simple.class)
assert_equal(SimpleDelegator,simple.dup.class)
assert_equal(SimpleDelegator,simple.clone.class)
end
class Object
def m
:o
end
private
def delegate_test_m
:o
end
end
class Foo
def m
:m
end
def delegate_test_m
:m
end
end
class Bar < DelegateClass(Foo)
end
def test_override
foo = Foo.new
foo2 = SimpleDelegator.new(foo)
bar = Bar.new(foo)
assert_equal(:o, Object.new.m)
assert_equal(:m, foo.m)
assert_equal(:m, foo2.m)
assert_equal(:m, bar.m)
bug = '[ruby-dev:39154]'
assert_equal(:m, foo2.send(:delegate_test_m), bug)
assert_equal(:m, bar.send(:delegate_test_m), bug)
end
class IV < DelegateClass(Integer)
attr_accessor :var
def initialize
@var = 1
super(0)
end
end
def test_marshal
bug1744 = '[ruby-core:24211]'
c = IV.new
assert_equal(1, c.var)
d = Marshal.load(Marshal.dump(c))
assert_equal(1, d.var, bug1744)
end
def test_copy_frozen
bug2679 = '[ruby-dev:40242]'
a = [42, :hello].freeze
d = SimpleDelegator.new(a)
assert_nothing_raised(bug2679) {d.dup[0] += 1}
assert_raise(RuntimeError) {d.clone[0] += 1}
d.freeze
assert(d.clone.frozen?)
assert(!d.dup.frozen?)
end
def test_frozen
d = SimpleDelegator.new([1, :foo])
d.freeze
assert_raise(RuntimeError, '[ruby-dev:40314]#1') {d.__setobj__("foo")}
assert_equal([1, :foo], d)
end
def test_instance_method
s = SimpleDelegator.new("foo")
m = s.method("upcase")
s.__setobj__([1,2,3])
assert_raise(NoMethodError, '[ruby-dev:40314]#3') {m.call}
end
class Foo
private
def delegate_test_private
:m
end
end
def test_private_method
foo = Foo.new
d = SimpleDelegator.new(foo)
assert_raise(NoMethodError) {foo.delegate_test_private}
assert_equal(:m, foo.send(:delegate_test_private))
assert_raise(NoMethodError, '[ruby-dev:40314]#4') {d.delegate_test_private}
assert_raise(NoMethodError, '[ruby-dev:40314]#5') {d.send(:delegate_test_private)}
end
end
|
