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