Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

461 lines (327 sloc) 12.268 kb
require File.expand_path '../xref_test_case', __FILE__
class TestRDocAnyMethod < 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_c_function
@c1_m.c_function = 'my_c1_m'
assert_equal 'my_c1_m', @c1_m.c_function
end
def test_call_seq_equals
m = RDoc::AnyMethod.new nil, nil
m.call_seq = ''
assert_nil m.call_seq
m.call_seq = 'foo'
assert_equal 'foo', m.call_seq
end
def test_full_name
assert_equal 'C1::m', @c1.method_list.first.full_name
end
def test_is_alias_for
assert_equal @c2_b, @c2_a.is_alias_for
# set string on instance variable
loaded = Marshal.load Marshal.dump @c2_a
loaded.store = @store
assert_equal @c2_b, loaded.is_alias_for, 'Marshal.load'
m1 = RDoc::AnyMethod.new nil, 'm1'
m1.store = @store
m1.instance_variable_set :@is_alias_for, ['Missing', false, 'method']
assert_nil m1.is_alias_for, 'missing alias'
end
def test_markup_code
tokens = [
RDoc::RubyToken::TkCONSTANT. new(0, 0, 0, 'CONSTANT'),
]
@c2_a.collect_tokens
@c2_a.add_tokens(*tokens)
expected = '<span class="ruby-constant">CONSTANT</span>'
assert_equal expected, @c2_a.markup_code
end
def test_markup_code_empty
assert_equal '', @c2_a.markup_code
end
def test_marshal_dump
@store.path = Dir.tmpdir
top_level = @store.add_file 'file.rb'
m = RDoc::AnyMethod.new nil, 'method'
m.block_params = 'some_block'
m.call_seq = 'call_seq'
m.comment = 'this is a comment'
m.params = 'param'
m.record_location top_level
cm = top_level.add_class RDoc::ClassModule, 'Klass'
cm.add_method m
section = cm.sections.first
al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
al_m = m.add_alias al, cm
loaded = Marshal.load Marshal.dump m
loaded.store = @store
comment = RDoc::Markup::Document.new(
RDoc::Markup::Paragraph.new('this is a comment'))
assert_equal m, loaded
assert_equal [al_m.name], loaded.aliases.map { |alas| alas.name }
assert_equal 'some_block', loaded.block_params
assert_equal 'call_seq', loaded.call_seq
assert_equal comment, loaded.comment
assert_equal top_level, loaded.file
assert_equal 'Klass#method', loaded.full_name
assert_equal 'method', loaded.name
assert_equal 'param', loaded.params
assert_equal nil, loaded.singleton # defaults to nil
assert_equal :public, loaded.visibility
assert_equal cm, loaded.parent
assert_equal section, loaded.section
end
def test_marshal_load_aliased_method
aliased_method = Marshal.load Marshal.dump(@c2_a)
aliased_method.store = @store
assert_equal 'C2#a', aliased_method.full_name
assert_equal 'C2', aliased_method.parent_name
assert_equal '()', aliased_method.params
assert_equal @c2_b, aliased_method.is_alias_for, 'is_alias_for'
assert aliased_method.display?
end
def test_marshal_load_class_method
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
assert class_method.display?
end
def test_marshal_load_instance_method
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
assert instance_method.display?
end
def test_marshal_load_version_0
@store.path = Dir.tmpdir
top_level = @store.add_file 'file.rb'
m = RDoc::AnyMethod.new nil, 'method'
cm = top_level.add_class RDoc::ClassModule, 'Klass'
cm.add_method m
section = cm.sections.first
al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
al_m = m.add_alias al, cm
loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x0Fi\x00I" +
"\"\vmethod\x06:\x06EF\"\x11Klass#method0:\vpublic" +
"o:\eRDoc::Markup::Document\x06:\v@parts[\x06" +
"o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
"\"\x16this is a comment\x06;\x06FI" +
"\"\rcall_seq\x06;\x06FI\"\x0Fsome_block\x06;\x06F" +
"[\x06[\aI\"\faliased\x06;\x06Fo;\b\x06;\t[\x06" +
"o;\n\x06;\t[\x06I\"\x12alias comment\x06;\x06FI" +
"\"\nparam\x06;\x06F"
loaded.store = @store
comment = RDoc::Markup::Document.new(
RDoc::Markup::Paragraph.new('this is a comment'))
assert_equal m, loaded
assert_equal [al_m.name], loaded.aliases.map { |alas| alas.name }
assert_equal 'some_block', loaded.block_params
assert_equal 'call_seq', loaded.call_seq
assert_equal comment, loaded.comment
assert_equal 'Klass#method', loaded.full_name
assert_equal 'method', loaded.name
assert_equal 'param', loaded.params
assert_equal nil, loaded.singleton # defaults to nil
assert_equal :public, loaded.visibility
assert_equal nil, loaded.file
assert_equal cm, loaded.parent
assert_equal section, loaded.section
assert_nil loaded.is_alias_for
assert loaded.display?
end
def test_marshal_dump_version_2
@store.path = Dir.tmpdir
top_level = @store.add_file 'file.rb'
m = RDoc::AnyMethod.new nil, 'method'
m.block_params = 'some_block'
m.call_seq = 'call_seq'
m.comment = 'this is a comment'
m.params = 'param'
m.record_location top_level
cm = top_level.add_class RDoc::ClassModule, 'Klass'
cm.add_method m
section = cm.sections.first
al = RDoc::Alias.new nil, 'method', 'aliased', 'alias comment'
al_m = m.add_alias al, cm
loaded = Marshal.load "\x04\bU:\x14RDoc::AnyMethod[\x14i\bI" +
"\"\vmethod\x06:\x06ETI" +
"\"\x11Klass#method\x06;\x06T0:\vpublic" +
"o:\eRDoc::Markup::Document\b:\v@parts[\x06" +
"o:\x1CRDoc::Markup::Paragraph\x06;\t[\x06I" +
"\"\x16this is a comment\x06;\x06T:\n@file0" +
":0@omit_headings_from_table_of_contents_below0" +
"I\"\rcall_seq\x06;\x06TI\"\x0Fsome_block\x06" +
";\x06T[\x06[\aI\"\faliased\x06;\x06To;\b\b;\t" +
"[\x06o;\n\x06;\t[\x06I\"\x12alias comment\x06" +
";\x06T;\v0;\f0I\"\nparam\x06;\x06TI" +
"\"\ffile.rb\x06;\x06TFI\"\nKlass\x06;\x06T" +
"c\x16RDoc::ClassModule0"
loaded.store = @store
comment = doc(para('this is a comment'))
assert_equal m, loaded
assert_equal [al_m.name], loaded.aliases.map { |alas| alas.name }
assert_equal 'some_block', loaded.block_params
assert_equal 'call_seq', loaded.call_seq
assert_equal comment, loaded.comment
assert_equal top_level, loaded.file
assert_equal 'Klass#method', loaded.full_name
assert_equal 'method', loaded.name
assert_equal 'param', loaded.params
assert_equal nil, loaded.singleton # defaults to nil
assert_equal :public, loaded.visibility
assert_equal cm, loaded.parent
assert_equal section, loaded.section
assert_nil loaded.is_alias_for
end
def test_name
m = RDoc::AnyMethod.new nil, nil
assert_nil m.name
end
def test_name_call_seq
m = RDoc::AnyMethod.new nil, nil
m.call_seq = "yields(name)\nyields(name, description)"
assert_equal 'yields', m.name
end
def test_name_call_seq_dot
m = RDoc::AnyMethod.new nil, nil
m.call_seq = "obj.yields(name)\nobj.yields(name, description)"
assert_equal 'yields', m.name
end
def test_param_list_block_params
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.block_params = 'c, d'
assert_equal %w[c d], m.param_list
end
def test_param_list_call_seq
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
call_seq = <<-SEQ
method(a) { |c| ... }
method(a, b) { |c, d| ... }
SEQ
m.call_seq = call_seq
assert_equal %w[a b c d], m.param_list
end
def test_param_list_default
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = '(b = default)'
assert_equal %w[b], m.param_list
end
def test_param_list_params
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = '(a, b)'
assert_equal %w[a b], m.param_list
end
def test_param_list_params_block_params
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = '(a, b)'
m.block_params = 'c, d'
assert_equal %w[a b c d], m.param_list
end
def test_param_list_empty_params_with_block
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = '()'
m.block_params = 'a, b'
assert_equal %w[a b], m.param_list
end
def test_param_list_ampersand_param_block_params
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = '(a, b, &block)'
m.block_params = 'c, d'
assert_equal %w[a b c d], m.param_list
end
def test_param_list_ampersand_param
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
m.params = '(a, b, &block)'
assert_equal %w[a b block], m.param_list
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_param_seq_call_seq
m = RDoc::AnyMethod.new nil, 'method'
m.parent = @c1
call_seq = <<-SEQ
method(a) { |c| ... }
method(a, b) { |c, d| ... }
SEQ
m.call_seq = call_seq
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
def test_store_equals
loaded = Marshal.load Marshal.dump(@c1.method_list.last)
loaded.store = @store
assert_equal @store, loaded.file.store
end
def test_superclass_method
m3 = RDoc::AnyMethod.new '', 'no_super'
m2 = RDoc::AnyMethod.new '', 'supers'
m2.calls_super = true
m1 = RDoc::AnyMethod.new '', 'supers'
c1 = RDoc::NormalClass.new 'Outer'
c1.store = @store
c1.add_method m1
c2 = RDoc::NormalClass.new 'Inner', c1
c2.store = @store
c2.add_method m2
c2.add_method m3
assert_nil m3.superclass_method,
'no superclass method for no_super'
assert_equal m1, m2.superclass_method,
'superclass method missing for supers'
end
def test_superclass_method_multilevel
m2 = RDoc::AnyMethod.new '', 'supers'
m2.calls_super = true
m1 = RDoc::AnyMethod.new '', 'supers'
c1 = RDoc::NormalClass.new 'Outer'
c1.store = @store
c1.add_method m1
c2 = RDoc::NormalClass.new 'Middle', c1
c2.store = @store
c3 = RDoc::NormalClass.new 'Inner', c2
c3.store = @store
c3.add_method m2
assert_equal m1, m2.superclass_method,
'superclass method missing for supers'
end
end
Jump to Line
Something went wrong with that request. Please try again.