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
|
require File.expand_path '../xref_test_case', __FILE__
require 'rdoc/code_objects'
require 'rdoc/generator/markup'
class RDocAnyMethodTest < XrefTestCase
def test_aref
m = RDoc::AnyMethod.new nil, 'method?'
assert_equal 'method-i-method-3F', m.aref
m.singleton = true
assert_equal 'method-c-method-3F', m.aref
end
def test_arglists
m = RDoc::AnyMethod.new nil, 'method'
assert_nil m.arglists
m.params = "(a, b)"
m.block_params = "c, d"
assert_equal "method(a, b) { |c, d| ... }", m.arglists
call_seq = <<-SEQ
method(a) { |c| ... }
method(a, b) { |c, d| ... }
SEQ
m.call_seq = call_seq.dup
assert_equal call_seq, m.arglists
end
def test_full_name
assert_equal 'C1::m', @c1.method_list.first.full_name
end
def test_markup_code
tokens = [
RDoc::RubyToken::TkCONSTANT. new(0, 0, 0, 'CONSTANT'),
RDoc::RubyToken::TkKW. new(0, 0, 0, 'KW'),
RDoc::RubyToken::TkIVAR. new(0, 0, 0, 'IVAR'),
RDoc::RubyToken::TkOp. new(0, 0, 0, 'Op'),
RDoc::RubyToken::TkId. new(0, 0, 0, 'Id'),
RDoc::RubyToken::TkNode. new(0, 0, 0, 'Node'),
RDoc::RubyToken::TkCOMMENT. new(0, 0, 0, 'COMMENT'),
RDoc::RubyToken::TkREGEXP. new(0, 0, 0, 'REGEXP'),
RDoc::RubyToken::TkSTRING. new(0, 0, 0, 'STRING'),
RDoc::RubyToken::TkVal. new(0, 0, 0, 'Val'),
RDoc::RubyToken::TkBACKSLASH.new(0, 0, 0, '\\'),
]
@c2_a.collect_tokens
@c2_a.add_tokens(*tokens)
expected = [
'<span class="ruby-constant">CONSTANT</span>',
'<span class="ruby-keyword">KW</span>',
'<span class="ruby-ivar">IVAR</span>',
'<span class="ruby-operator">Op</span>',
'<span class="ruby-identifier">Id</span>',
'<span class="ruby-node">Node</span>',
'<span class="ruby-comment">COMMENT</span>',
'<span class="ruby-regexp">REGEXP</span>',
'<span class="ruby-string">STRING</span>',
'<span class="ruby-value">Val</span>',
'\\'
].join
assert_equal expected, @c2_a.markup_code
end
def test_markup_code_empty
assert_equal '', @c2_a.markup_code
end
def test_marshal_load
instance_method = Marshal.load Marshal.dump(@c1.method_list.last)
assert_equal 'C1#m', instance_method.full_name
assert_equal 'C1', instance_method.parent_name
assert_equal '(foo)', instance_method.params
class_method = Marshal.load Marshal.dump(@c1.method_list.first)
assert_equal 'C1::m', class_method.full_name
assert_equal 'C1', class_method.parent_name
assert_equal '()', class_method.params
end
def test_name
m = RDoc::AnyMethod.new nil, nil
assert_nil m.name
end
def test_param_seq
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = 'a'
assert_equal '(a)', m.param_seq
m.params = '(a)'
assert_equal '(a)', m.param_seq
m.params = "(a,\n b)"
assert_equal '(a, b)', m.param_seq
m.block_params = "c,\n d"
assert_equal '(a, b) { |c, d| ... }', m.param_seq
end
def test_parent_name
assert_equal 'C1', @c1.method_list.first.parent_name
assert_equal 'C1', @c1.method_list.last.parent_name
end
end
|