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
|
require "spec"
require "../support/finalize"
private module ReferenceSpec
class TestClass
@x : Int32
@y : String
def initialize(@x, @y)
end
end
class TestClassBase
end
class TestClassSubclass < TestClassBase
end
class DupCloneClass
getter x, y
def initialize
@x = 1
@y = "y"
end
def_clone
end
class DupCloneRecursiveClass
getter x, y, z
def initialize
@x = 1
@y = [1, 2, 3]
@z = self
end
def_clone
end
abstract class Abstract
end
class Concrete < Abstract
property x
def initialize(@x : Int32)
end
end
class TestClassWithFinalize
include FinalizeCounter
end
end
describe "Reference" do
it "compares reference to other reference" do
o1 = Reference.new
o2 = Reference.new
(o1 == o1).should be_true
(o1 == o2).should be_false
(o1 == 1).should be_false
end
it "should not be nil" do
Reference.new.nil?.should be_false
end
it "should be false when negated" do
(!Reference.new).should be_false
end
it "does inspect" do
r = ReferenceSpec::TestClass.new(1, "hello")
r.inspect.should eq(%(#<ReferenceSpec::TestClass:0x#{r.object_id.to_s(16)} @x=1, @y="hello">))
end
it "does to_s" do
r = ReferenceSpec::TestClass.new(1, "hello")
r.to_s.should eq(%(#<ReferenceSpec::TestClass:0x#{r.object_id.to_s(16)}>))
end
it "does inspect for class" do
String.inspect.should eq("String")
end
it "does to_s for class" do
String.to_s.should eq("String")
end
it "does to_s for class if virtual" do
[ReferenceSpec::TestClassBase, ReferenceSpec::TestClassSubclass].to_s.should eq("[ReferenceSpec::TestClassBase, ReferenceSpec::TestClassSubclass]")
end
it "returns itself" do
x = "hello"
x.itself.should be(x)
end
it "dups" do
original = ReferenceSpec::DupCloneClass.new
duplicate = original.dup
duplicate.should_not be(original)
duplicate.x.should eq(original.x)
duplicate.y.should be(original.y)
end
it "can dup class that inherits abstract class" do
original = ReferenceSpec::Concrete.new(2).as(ReferenceSpec::Abstract)
duplicate = original.dup
duplicate.should be_a(ReferenceSpec::Concrete)
duplicate.should_not be(original)
duplicate.x.should eq(original.x)
end
it "clones with def_clone" do
original = ReferenceSpec::DupCloneClass.new
clone = original.clone
clone.should_not be(original)
clone.x.should eq(original.x)
end
it "clones with def_clone (recursive type)" do
original = ReferenceSpec::DupCloneRecursiveClass.new
clone = original.clone
clone.should_not be(original)
clone.x.should eq(original.x)
clone.y.should_not be(original.y)
clone.y.should eq(original.y)
clone.z.should be(clone)
end
it "pretty_print" do
ReferenceSpec::TestClassBase.new.pretty_inspect.should match(/\A#<ReferenceSpec::TestClassBase:0x[0-9a-f]+>\Z/)
ReferenceSpec::TestClass.new(42, "foo").pretty_inspect.should match(/\A#<ReferenceSpec::TestClass:0x[0-9a-f]+ @x=42, @y="foo">\Z/)
end
it "calls #finalize on #dup'ed objects" do
obj = ReferenceSpec::TestClassWithFinalize.new
assert_finalizes("dup") { obj.dup }
end
end
|
