1require File.expand_path '../xref_test_case', __FILE__
2
3class TestRDocAnyMethod < XrefTestCase
4
5  def test_aref
6    m = RDoc::AnyMethod.new nil, 'method?'
7
8    assert_equal 'method-i-method-3F', m.aref
9
10    m.singleton = true
11
12    assert_equal 'method-c-method-3F', m.aref
13  end
14
15  def test_arglists
16    m = RDoc::AnyMethod.new nil, 'method'
17
18    assert_nil m.arglists
19
20    m.params = "(a, b)"
21    m.block_params = "c, d"
22
23    assert_equal "method(a, b) { |c, d| ... }", m.arglists
24
25    call_seq = <<-SEQ
26method(a) { |c| ... }
27method(a, b) { |c, d| ... }
28    SEQ
29
30    m.call_seq = call_seq.dup
31
32    assert_equal call_seq, m.arglists
33  end
34
35  def test_c_function
36    @c1_m.c_function = 'my_c1_m'
37
38    assert_equal 'my_c1_m', @c1_m.c_function
39  end
40
41  def test_full_name
42    assert_equal 'C1::m', @c1.method_list.first.full_name
43  end
44
45  def test_markup_code
46    tokens = [
47      RDoc::RubyToken::TkCONSTANT. new(0, 0, 0, 'CONSTANT'),
48    ]
49
50    @c2_a.collect_tokens
51    @c2_a.add_tokens(*tokens)
52
53    expected = '<span class="ruby-constant">CONSTANT</span>'
54
55    assert_equal expected, @c2_a.markup_code
56  end
57
58  def test_markup_code_empty
59    assert_equal '', @c2_a.markup_code
60  end
61
62  def test_marshal_dump
63    @store.path = Dir.tmpdir
64    top_level = @store.add_file 'file.rb'
65
66    m = RDoc::AnyMethod.new nil, 'method'
67    m.block_params = 'some_block'
68    m.call_seq     = 'call_seq'
69    m.comment      = 'this is a comment'
70    m.params       = 'param'
71    m.record_location top_level
72
73    cm = top_level.add_class RDoc::ClassModule, 'Klass'
74    cm.add_method m
75
76    section = cm.sections.first
77
78    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
79    al_m = m.add_alias al, cm
80
81    loaded = Marshal.load Marshal.dump m
82    loaded.store = @store
83
84    comment = RDoc::Markup::Document.new(
85                RDoc::Markup::Paragraph.new('this is a comment'))
86
87    assert_equal m, loaded
88
89    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
90    assert_equal 'some_block',   loaded.block_params
91    assert_equal 'call_seq',     loaded.call_seq
92    assert_equal comment,        loaded.comment
93    assert_equal top_level,      loaded.file
94    assert_equal 'Klass#method', loaded.full_name
95    assert_equal 'method',       loaded.name
96    assert_equal 'param',        loaded.params
97    assert_equal nil,            loaded.singleton # defaults to nil
98    assert_equal :public,        loaded.visibility
99    assert_equal cm,             loaded.parent
100    assert_equal section,        loaded.section
101  end
102
103  def test_marshal_load_aliased_method
104    aliased_method = Marshal.load Marshal.dump(@c2.method_list.last)
105
106    assert_equal 'C2#a',  aliased_method.full_name
107    assert_equal 'C2',    aliased_method.parent_name
108    assert_equal '()',    aliased_method.params
109    assert                aliased_method.display?
110  end
111
112  def test_marshal_load_class_method
113    class_method = Marshal.load Marshal.dump(@c1.method_list.first)
114
115    assert_equal 'C1::m', class_method.full_name
116    assert_equal 'C1',    class_method.parent_name
117    assert_equal '()',    class_method.params
118    assert                class_method.display?
119  end
120
121  def test_marshal_load_instance_method
122    instance_method = Marshal.load Marshal.dump(@c1.method_list.last)
123
124    assert_equal 'C1#m',  instance_method.full_name
125    assert_equal 'C1',    instance_method.parent_name
126    assert_equal '(foo)', instance_method.params
127    assert                instance_method.display?
128  end
129
130  def test_marshal_load_version_0
131    @store.path = Dir.tmpdir
132    top_level = @store.add_file 'file.rb'
133
134    m = RDoc::AnyMethod.new nil, 'method'
135
136    cm = top_level.add_class RDoc::ClassModule, 'Klass'
137    cm.add_method m
138
139    section = cm.sections.first
140
141    al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
142    al_m = m.add_alias al, cm
143
144    loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
145                          "\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
146                          "o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
147                          "o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
148                          "\"\x16this is a comment\x06;\x06FI" +
149                          "\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
150                          "[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
151                          "o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
152                          "\"\nparam\x06;\x06F"
153
154    loaded.store = @store
155
156    comment = RDoc::Markup::Document.new(
157                RDoc::Markup::Paragraph.new('this is a comment'))
158
159    assert_equal m, loaded
160
161    assert_equal [al_m.name],    loaded.aliases.map { |alas| alas.name }
162    assert_equal 'some_block',   loaded.block_params
163    assert_equal 'call_seq',     loaded.call_seq
164    assert_equal comment,        loaded.comment
165    assert_equal 'Klass#method', loaded.full_name
166    assert_equal 'method',       loaded.name
167    assert_equal 'param',        loaded.params
168    assert_equal nil,            loaded.singleton # defaults to nil
169    assert_equal :public,        loaded.visibility
170    assert_equal nil,            loaded.file
171    assert_equal cm,             loaded.parent
172    assert_equal section,        loaded.section
173
174    assert loaded.display?
175  end
176
177  def test_name
178    m = RDoc::AnyMethod.new nil, nil
179
180    assert_nil m.name
181  end
182
183  def test_param_list_block_params
184    m = RDoc::AnyMethod.new nil, 'method'
185    m.parent = @c1
186
187    m.block_params = 'c, d'
188
189    assert_equal %w[c d], m.param_list
190  end
191
192  def test_param_list_call_seq
193    m = RDoc::AnyMethod.new nil, 'method'
194    m.parent = @c1
195
196    call_seq = <<-SEQ
197method(a) { |c| ... }
198method(a, b) { |c, d| ... }
199    SEQ
200
201    m.call_seq = call_seq
202
203    assert_equal %w[a b c d], m.param_list
204  end
205
206  def test_param_list_default
207    m = RDoc::AnyMethod.new nil, 'method'
208    m.parent = @c1
209
210    m.params = '(b = default)'
211
212    assert_equal %w[b], m.param_list
213  end
214
215  def test_param_list_params
216    m = RDoc::AnyMethod.new nil, 'method'
217    m.parent = @c1
218
219    m.params = '(a, b)'
220
221    assert_equal %w[a b], m.param_list
222  end
223
224  def test_param_list_params_block_params
225    m = RDoc::AnyMethod.new nil, 'method'
226    m.parent = @c1
227
228    m.params = '(a, b)'
229    m.block_params = 'c, d'
230
231    assert_equal %w[a b c d], m.param_list
232  end
233
234  def test_param_seq
235    m = RDoc::AnyMethod.new nil, 'method'
236    m.parent = @c1
237    m.params = 'a'
238
239    assert_equal '(a)', m.param_seq
240
241    m.params = '(a)'
242
243    assert_equal '(a)', m.param_seq
244
245    m.params = "(a,\n  b)"
246
247    assert_equal '(a, b)', m.param_seq
248
249    m.block_params = "c,\n  d"
250
251    assert_equal '(a, b) { |c, d| ... }', m.param_seq
252  end
253
254  def test_param_seq_call_seq
255    m = RDoc::AnyMethod.new nil, 'method'
256    m.parent = @c1
257
258    call_seq = <<-SEQ
259method(a) { |c| ... }
260method(a, b) { |c, d| ... }
261    SEQ
262
263    m.call_seq = call_seq
264
265    assert_equal '(a, b) { |c, d| }', m.param_seq
266
267  end
268
269  def test_parent_name
270    assert_equal 'C1', @c1.method_list.first.parent_name
271    assert_equal 'C1', @c1.method_list.last.parent_name
272  end
273
274  def test_store_equals
275    loaded = Marshal.load Marshal.dump(@c1.method_list.last)
276
277    loaded.store = @store
278
279    assert_equal @store, loaded.file.store
280  end
281
282  def test_superclass_method
283    m3 = RDoc::AnyMethod.new '', 'no_super'
284
285    m2 = RDoc::AnyMethod.new '', 'supers'
286    m2.calls_super = true
287
288    m1 = RDoc::AnyMethod.new '', 'supers'
289
290    c1 = RDoc::NormalClass.new 'Outer'
291    c1.store = @store
292    c1.add_method m1
293
294    c2 = RDoc::NormalClass.new 'Inner', c1
295    c2.store = @store
296    c2.add_method m2
297    c2.add_method m3
298
299    assert_nil m3.superclass_method,
300               'no superclass method for no_super'
301
302    assert_equal m1, m2.superclass_method,
303                 'superclass method missing for supers'
304  end
305
306  def test_superclass_method_multilevel
307    m2 = RDoc::AnyMethod.new '', 'supers'
308    m2.calls_super = true
309
310    m1 = RDoc::AnyMethod.new '', 'supers'
311
312    c1 = RDoc::NormalClass.new 'Outer'
313    c1.store = @store
314    c1.add_method m1
315
316    c2 = RDoc::NormalClass.new 'Middle', c1
317    c2.store = @store
318
319    c3 = RDoc::NormalClass.new 'Inner', c2
320    c3.store = @store
321    c3.add_method m2
322
323    assert_equal m1, m2.superclass_method,
324                 'superclass method missing for supers'
325  end
326
327end
328
329