yard 0.8.7.6 → 0.9.0

data/spec/handlers/module_handler_spec.rb

@@ -3,32 +3,32 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}ModuleHandler" do
   before(:all) { parse_file :module_handler_001, __FILE__ }
 
-  it "should parse a module block" do
-    Registry.at(:ModName).should_not == nil
-    Registry.at("ModName::OtherModName").should_not == nil
+  it "parses a module block" do
+    expect(Registry.at(:ModName)).not_to eq nil
+    expect(Registry.at("ModName::OtherModName")).not_to eq nil
   end
 
-  it "should attach docstring" do
-    Registry.at("ModName::OtherModName").docstring.should == "Docstring"
+  it "attaches docstring" do
+    expect(Registry.at("ModName::OtherModName").docstring).to eq "Docstring"
   end
 
-  it "should handle any formatting" do
-    Registry.at(:StressTest).should_not == nil
+  it "handles any formatting" do
+    expect(Registry.at(:StressTest)).not_to eq nil
   end
 
-  it "should handle complex module names" do
-    Registry.at("A::B").should_not == nil
+  it "handles complex module names" do
+    expect(Registry.at("A::B")).not_to eq nil
   end
 
-  it "should handle modules in the form ::ModName" do
-    Registry.at("Kernel").should_not be_nil
+  it "handles modules in the form ::ModName" do
+    expect(Registry.at("Kernel")).not_to be nil
   end
 
-  it "should list mixins in proper order" do
-    Registry.at('D').mixins.should == [P(:C), P(:B), P(:A)]
+  it "lists mixins in proper order" do
+    expect(Registry.at('D').mixins).to eq [P(:C), P(:B), P(:A)]
   end
 
-  it "should create proper module when constant is in namespace" do
-    Registry.at('Q::FOO::A').should_not be_nil
+  it "creates proper module when constant is in namespace" do
+    expect(Registry.at('Q::FOO::A')).not_to be nil
   end
 end

data/spec/handlers/private_class_method_handler_spec.rb

@@ -1,54 +1,10 @@
 require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
 
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateClassMethodHandler" do
-  before(:all) { parse_file :private_class_method_handler_001, __FILE__ }
+  before { Registry.clear }
 
-  it "should handle private_class_method statement" do
-    Registry.at('A.c').visibility.should eq :private
-    Registry.at('A.d').visibility.should eq :private
-    Registry.at('A.e').visibility.should eq :private
-  end
+  let(:visibility) { :private }
 
-  it "should fail if parameter is not String or Symbol" do
-    undoc_error 'class Foo; X = 1; private_class_method X.new("hi"); end'
-    undoc_error 'class Foo; X = 1; private_class_method 123; end'
-  end unless LEGACY_PARSER
-
-  # Issue #760
-  # https://github.com/lsegal/yard/issues/760
-  it "should handle singleton classes" do
-    # Note: It's important to def a method within the singleton class or
-    #       the bug may not trigger.
-    code = 'class SingletonClass; private_class_method :new; def self.foo; "foo"end; end'
-    StubbedSourceParser.parse_string(code) # Should be successful.
-  end unless LEGACY_PARSER
-  
-  
-  describe "should handle reopened class" do
-    
-    # Modified #parse_file from '/spec/spec_helper.rb' because the second example
-    # file was overwriting the data from the first example when trying to reopen
-    # the class.
-    def parse_files(files, thisfile = __FILE__, log_level = log.level, ext = '.rb.txt')
-      Registry.clear
-      paths = files.map { |file| File.join(File.dirname(thisfile), 'examples', file.to_s + ext) }
-      YARD::Parser::SourceParser.parse(paths, [], log_level)
-    end
-    
-    before {
-      parse_files [
-        :private_class_method_handler_002,
-        :private_class_method_handler_003
-      ], __FILE__
-    }
-    
-    specify do
-      Registry.at('SingletonClass.foo').visibility.should eq :public
-      Registry.at('SingletonClass.bar').visibility.should eq :private
-      Registry.at('SingletonClass.baz').visibility.should eq :private
-      Registry.at('SingletonClass.bat').visibility.should eq :public
-    end
-    
-  end unless LEGACY_PARSER # reopened class
-   
+  include_examples "class method visibility decorator"
 end

data/spec/handlers/private_constant_handler_spec.rb

@@ -3,22 +3,22 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PrivateConstantHandler" do
   before(:all) { parse_file :private_constant_handler_001, __FILE__ }
 
-  it "should handle private_constant statement" do
-    Registry.at('A::Foo').visibility.should == :private
-    Registry.at('A::B').visibility.should == :private
-    Registry.at('A::C').visibility.should == :private
+  it "handles private_constant statement" do
+    expect(Registry.at('A::Foo').visibility).to eq :private
+    expect(Registry.at('A::B').visibility).to eq :private
+    expect(Registry.at('A::C').visibility).to eq :private
   end
 
-  it "should make all other constants public" do
-    Registry.at('A::D').visibility.should == :public
+  it "makes all other constants public" do
+    expect(Registry.at('A::D').visibility).to eq :public
   end
 
-  it "should fail if parameter is not String, Symbol or Constant" do
+  it "fails if parameter is not String, Symbol or Constant" do
     undoc_error 'class Foo; private_constant x; end'
     undoc_error 'class Foo; X = 1; private_constant X.new("hi"); end'
   end unless LEGACY_PARSER
 
-  it "should fail if constant can't be recognized" do
+  it "fails if constant can't be recognized" do
     undoc_error 'class Foo2; private_constant :X end'
   end
 end

data/spec/handlers/processor_spec.rb

@@ -5,30 +5,30 @@ describe YARD::Handlers::Processor do
     @proc = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
   end
 
-  it "should start with public visibility" do
-    @proc.visibility.should == :public
+  it "starts with public visibility" do
+    expect(@proc.visibility).to eq :public
   end
 
-  it "should start in instance scope" do
-    @proc.scope.should == :instance
+  it "starts in instance scope" do
+    expect(@proc.scope).to eq :instance
   end
 
-  it "should start in root namespace" do
-    @proc.namespace.should == Registry.root
+  it "starts in root namespace" do
+    expect(@proc.namespace).to eq Registry.root
   end
 
-  it "should have a globals structure" do
-    @proc.globals.should be_a(OpenStruct)
+  it "has a globals structure" do
+    expect(@proc.globals).to be_a(OpenStruct)
   end
 
-  it 'should ignore HandlerAborted exceptions (but print debug info)' do
+  it "ignores HandlerAborted exceptions (but print debug info)" do
     class AbortHandlerProcessor < YARD::Handlers::Ruby::Base
       process { abort! }
     end
     stmt = OpenStruct.new(:line => 1, :show => 'SOURCE')
-    @proc.stub!(:find_handlers).and_return([AbortHandlerProcessor])
-    log.should_receive(:debug).with(/AbortHandlerProcessor cancelled from/)
-    log.should_receive(:debug).with("\tin file '(stdin)':1:\n\nSOURCE\n")
+    allow(@proc).to receive(:find_handlers).and_return([AbortHandlerProcessor])
+    expect(log).to receive(:debug).with(/AbortHandlerProcessor cancelled from/)
+    expect(log).to receive(:debug).with("\tin file '(stdin)':1:\n\nSOURCE\n")
     @proc.process([stmt])
   end
 end

data/spec/handlers/public_class_method_handler_spec.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/class_method_handler_shared_examples'
+
+describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}PublicClassMethodHandler" do
+  before { Registry.clear }
+
+  let(:visibility) { :public }
+
+  include_examples "class method visibility decorator"
+end

data/spec/handlers/ruby/base_spec.rb

@@ -4,7 +4,7 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
   include YARD::Parser::Ruby; YARD::Parser::Ruby::AstNode
 
   before do
-    Handlers::Ruby::Base.stub!(:inherited)
+    allow(Handlers::Ruby::Base).to receive(:inherited)
     @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby))
   end
 
@@ -13,67 +13,67 @@ describe YARD::Handlers::Ruby::Base, '#valid_handler?' do
   end
 
   def valid(handler, stmt)
-    @processor.find_handlers(stmt).should include(handler)
+    expect(@processor.find_handlers(stmt)).to include(handler)
   end
 
   def invalid(handler, stmt)
-    @processor.find_handlers(stmt).should_not include(handler)
+    expect(@processor.find_handlers(stmt)).not_to include(handler)
   end
 
-  it "should only handle Handlers inherited from Ruby::Base class" do
+  it "only handles Handlers inherited from Ruby::Base class" do
     class IgnoredHandler < Handlers::Base
       handles :list
     end
     class NotIgnoredHandler < Handlers::Ruby::Base
       handles :list
     end
-    Handlers::Base.stub!(:subclasses).and_return [IgnoredHandler, NotIgnoredHandler]
-    @processor.find_handlers(s()).should == [NotIgnoredHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [IgnoredHandler, NotIgnoredHandler]
+    expect(@processor.find_handlers(s())).to eq [NotIgnoredHandler]
   end
 
-  it "should handle string input (matches AstNode#source)" do
+  it "handles string input (matches AstNode#source)" do
     class StringHandler < Handlers::Ruby::Base
       handles "x"
     end
-    Handlers::Base.stub!(:subclasses).and_return [StringHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [StringHandler]
     ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
     valid StringHandler, ast[0][0][0]
     invalid StringHandler, ast[0][1]
   end
 
-  it "should handle symbol input (matches AstNode#type)" do
+  it "handles symbol input (matches AstNode#type)" do
     class SymbolHandler < Handlers::Ruby::Base
       handles :myNodeType
     end
-    Handlers::Base.stub!(:subclasses).and_return [SymbolHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [SymbolHandler]
     valid SymbolHandler, s(:myNodeType, s(1, 2, 3))
     invalid SymbolHandler, s(:NOTmyNodeType, s(1, 2, 3))
   end
 
-  it "should handle regex input (matches AstNode#source)" do
+  it "handles regex input (matches AstNode#source)" do
     class RegexHandler < Handlers::Ruby::Base
       handles %r{^if x ==}
     end
-    Handlers::Base.stub!(:subclasses).and_return [RegexHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [RegexHandler]
     ast = Parser::Ruby::RubyParser.parse("if x == 2 then true end").ast
     valid RegexHandler, ast
     invalid RegexHandler, ast[0][1]
   end
 
-  it "should handle AstNode input (matches AST literally)" do
+  it "handles AstNode input (matches AST literally)" do
     class ASTHandler < Handlers::Ruby::Base
       handles s(:vcall, s(:ident, "hello_world"))
     end
-    Handlers::Base.stub!(:subclasses).and_return [ASTHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [ASTHandler]
     valid ASTHandler, s(:vcall, s(:ident, "hello_world"))
     invalid ASTHandler, s(:vcall, s(:ident, "NOTHELLOWORLD"))
   end
 
-  it "should handle #method_call(:methname) on a valid AST" do
+  it "handles #method_call(:methname) on a valid AST" do
     class MethCallHandler < Handlers::Ruby::Base
       handles method_call(:meth)
     end
-    Handlers::Base.stub!(:subclasses).and_return [MethCallHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [MethCallHandler]
     ast = Parser::Ruby::RubyParser.parse(<<-"eof").ast
       meth                   # 0
       meth()                 # 1

data/spec/handlers/ruby/legacy/base_spec.rb

@@ -4,8 +4,10 @@ include Parser::Ruby::Legacy
 
 describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
   before do
-    Handlers::Ruby::Legacy::Base.stub!(:inherited)
-    Handlers::Ruby::Legacy::MixinHandler.stub!(:inherited) # fixes a Ruby1.9 issue
+    allow(Handlers::Ruby::Legacy::Base).to receive(:inherited)
+    if RUBY_VERSION > '1.8.7'
+      allow(Handlers::Ruby::Legacy::MixinHandler).to receive(:inherited) # fixes a Ruby1.9 issue
+    end
     @processor = Handlers::Processor.new(OpenStruct.new(:parser_type => :ruby18))
   end
 
@@ -17,45 +19,45 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
     Statement.new(TokenList.new(string))
   end
 
-  it "should only handle Handlers inherited from Ruby::Legacy::Base class" do
+  it "only handles Handlers inherited from Ruby::Legacy::Base class" do
     class IgnoredHandler < Handlers::Base
       handles "hello"
     end
     class NotIgnoredHandlerLegacy < Handlers::Ruby::Legacy::Base
       handles "hello"
     end
-    Handlers::Base.stub!(:subclasses).and_return [IgnoredHandler, NotIgnoredHandlerLegacy]
-    @processor.find_handlers(stmt("hello world")).should == [NotIgnoredHandlerLegacy]
+    allow(Handlers::Base).to receive(:subclasses).and_return [IgnoredHandler, NotIgnoredHandlerLegacy]
+    expect(@processor.find_handlers(stmt("hello world"))).to eq [NotIgnoredHandlerLegacy]
   end
 
-  it "should handle a string input" do
+  it "handles a string input" do
     class TestStringHandler < Handlers::Ruby::Legacy::Base
       handles "hello"
     end
 
-    TestStringHandler.handles?(stmt("hello world")).should be_true
-    TestStringHandler.handles?(stmt("nothello world")).should be_false
+    expect(TestStringHandler.handles?(stmt("hello world"))).to be true
+    expect(TestStringHandler.handles?(stmt("nothello world"))).to be false
   end
 
-  it "should handle regex input" do
+  it "handles regex input" do
     class TestRegexHandler < Handlers::Ruby::Legacy::Base
       handles /^nothello$/
     end
 
-    TestRegexHandler.handles?(stmt("nothello")).should be_true
-    TestRegexHandler.handles?(stmt("not hello hello")).should be_false
+    expect(TestRegexHandler.handles?(stmt("nothello"))).to be true
+    expect(TestRegexHandler.handles?(stmt("not hello hello"))).to be false
   end
 
-  it "should handle token input" do
+  it "handles token input" do
     class TestTokenHandler < Handlers::Ruby::Legacy::Base
       handles TkMODULE
     end
 
-    TestTokenHandler.handles?(stmt("module")).should be_true
-    TestTokenHandler.handles?(stmt("if")).should be_false
+    expect(TestTokenHandler.handles?(stmt("module"))).to be true
+    expect(TestTokenHandler.handles?(stmt("if"))).to be false
   end
 
-  it "should parse a do/end or { } block with #parse_block" do
+  it "parses a do/end or { } block with #parse_block" do
     class MyBlockHandler < Handlers::Ruby::Legacy::Base
       handles /\AmyMethod\b/
       def process
@@ -70,13 +72,13 @@ describe YARD::Handlers::Ruby::Legacy::Base, "#handles and inheritance" do
       def process; @@reached = true end
     end
 
-    Handlers::Base.stub!(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
+    allow(Handlers::Base).to receive(:subclasses).and_return [MyBlockHandler, MyBlockInnerHandler]
     Parser::SourceParser.parser_type = :ruby18
     Parser::SourceParser.parse_string "myMethod do inner end"
-    MyBlockInnerHandler.should be_reached
+    expect(MyBlockInnerHandler).to be_reached
     MyBlockInnerHandler.reset
     Parser::SourceParser.parse_string "myMethod { inner }"
-    MyBlockInnerHandler.should be_reached
+    expect(MyBlockInnerHandler).to be_reached
     Parser::SourceParser.parser_type = :ruby
   end
 end

data/spec/handlers/spec_helper.rb

@@ -4,7 +4,7 @@ require 'stringio'
 include Handlers
 
 def undoc_error(code)
-  lambda { StubbedSourceParser.parse_string(code) }.should raise_error(Parser::UndocumentableError)
+  expect { StubbedSourceParser.parse_string(code) }.to raise_error(Parser::UndocumentableError)
 end
 
 def with_parser(parser_type, &block)

data/spec/handlers/visibility_handler_spec.rb

@@ -3,37 +3,41 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}VisibilityHandler" do
   before(:all) { parse_file :visibility_handler_001, __FILE__ }
 
-  it "should be able to set visibility to public" do
-    Registry.at("Testing#pub").visibility.should == :public
-    Registry.at("Testing#pub2").visibility.should == :public
+  it "is able to set visibility to public" do
+    expect(Registry.at("Testing#pub").visibility).to eq :public
+    expect(Registry.at("Testing#pub2").visibility).to eq :public
   end
 
-  it "should be able to set visibility to private" do
-    Registry.at("Testing#priv").visibility.should == :private
+  it "is able to set visibility to private" do
+    expect(Registry.at("Testing#priv").visibility).to eq :private
   end
 
-  it "should be able to set visibility to protected" do
-    Registry.at("Testing#prot").visibility.should == :protected
+  it "is able to set visibility to protected" do
+    expect(Registry.at("Testing#prot").visibility).to eq :protected
   end
 
-  it "should support parameters and only set visibility on those methods" do
-    Registry['Testing#notpriv'].visibility.should == :protected
-    Registry['Testing#notpriv2'].visibility.should == :protected
-    Registry['Testing#notpriv?'].visibility.should == :protected
+  it "supports parameters and only set visibility on those methods" do
+    expect(Registry.at('Testing#notpriv').visibility).to eq :protected
+    expect(Registry.at('Testing#notpriv2').visibility).to eq :protected
+    expect(Registry.at('Testing#notpriv?').visibility).to eq :protected
   end
 
-  it "should only accept strings and symbols" do
-    Registry.at('Testing#name').should be_nil
-    Registry.at('Testing#argument').should be_nil
-    Registry.at('Testing#method_call').should be_nil
+  it "only accepts strings and symbols" do
+    expect(Registry.at('Testing#name')).to be nil
+    expect(Registry.at('Testing#argument')).to be nil
+    expect(Registry.at('Testing#method_call')).to be nil
   end
 
-  it "should handle constants passed in as symbols" do
-    Registry.at('Testing#Foo').visibility.should == :private
+  it "handles constants passed in as symbols" do
+    expect(Registry.at('Testing#Foo').visibility).to eq :private
   end
 
-  it 'should not register classes with visibility' do
-    Registry.at('Testing::Bar').visibility.should == :public
-    Registry.at('Testing::Baz').visibility.should == :public
+  it "does not register classes with visibility" do
+    expect(Registry.at('Testing::Bar').visibility).to eq :public
+    expect(Registry.at('Testing::Baz').visibility).to eq :public
   end
-end
+  
+  it "can decorate a method definition" do
+    expect(Registry.at('Testing#decpriv').visibility).to eq :private
+  end unless LEGACY_PARSER
+end

data/spec/handlers/yield_handler_spec.rb

@@ -3,49 +3,49 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe "YARD::Handlers::Ruby::#{LEGACY_PARSER ? "Legacy::" : ""}YieldHandler" do
   before(:all) { parse_file :yield_handler_001, __FILE__ }
 
-  it "should only parse yield blocks in methods" do
-    P(:Testing).tag(:yield).should be_nil
-    P(:Testing).tag(:yieldparam).should be_nil
+  it "only parses yield blocks in methods" do
+    expect(P(:Testing).tag(:yield)).to be nil
+    expect(P(:Testing).tag(:yieldparam)).to be nil
   end
 
-  it "should handle an empty yield statement" do
-    P('Testing#mymethod').tag(:yield).should be_nil
-    P('Testing#mymethod').tag(:yieldparam).should be_nil
+  it "handles an empty yield statement" do
+    expect(P('Testing#mymethod').tag(:yield)).to be nil
+    expect(P('Testing#mymethod').tag(:yieldparam)).to be nil
   end
 
-  it "should not document a yield statement in a method with either @yield or @yieldparam" do
-    P('Testing#mymethod2').tag(:yield).types.should == ['a', 'b']
-    P('Testing#mymethod2').tag(:yield).text.should == "Blah"
-    P('Testing#mymethod2').tags(:yieldparam).size.should == 2
+  it "does not document a yield statement in a method with either @yield or @yieldparam" do
+    expect(P('Testing#mymethod2').tag(:yield).types).to eq ['a', 'b']
+    expect(P('Testing#mymethod2').tag(:yield).text).to eq "Blah"
+    expect(P('Testing#mymethod2').tags(:yieldparam).size).to eq 2
 
-    P('Testing#mymethod3').tag(:yield).types.should == ['a', 'b']
-    P('Testing#mymethod3').tags(:yieldparam).size.should == 0
+    expect(P('Testing#mymethod3').tag(:yield).types).to eq ['a', 'b']
+    expect(P('Testing#mymethod3').tags(:yieldparam).size).to eq 0
 
-    P('Testing#mymethod4').tag(:yieldparam).name.should == '_self'
-    P('Testing#mymethod4').tag(:yieldparam).text.should == 'BLAH'
+    expect(P('Testing#mymethod4').tag(:yieldparam).name).to eq '_self'
+    expect(P('Testing#mymethod4').tag(:yieldparam).text).to eq 'BLAH'
   end
 
-  it "should handle any arbitrary yield statement" do
-    P('Testing#mymethod5').tag(:yield).types.should == [':a', 'b', '_self', 'File.read(\'file\', \'w\')', 'CONSTANT']
+  it "handles any arbitrary yield statement" do
+    expect(P('Testing#mymethod5').tag(:yield).types).to eq [':a', 'b', '_self', 'File.read(\'file\', \'w\')', 'CONSTANT']
   end
 
-  it "should handle parentheses" do
-    P('Testing#mymethod6').tag(:yield).types.should == ['b', 'a']
+  it "handles parentheses" do
+    expect(P('Testing#mymethod6').tag(:yield).types).to eq ['b', 'a']
   end
 
-  it "should only document the first yield statement in a method (limitation of yield handler)" do
-    P('Testing#mymethod7').tag(:yield).types.should == ['a']
+  it "only documents the first yield statement in a method (limitation of yield handler)" do
+    expect(P('Testing#mymethod7').tag(:yield).types).to eq ['a']
   end
 
-  it "should handle `self` keyword and list object type as yieldparam for _self" do
-    P('Testing#mymethod8').tag(:yield).types.should == ['_self']
-    P('Testing#mymethod8').tag(:yieldparam).types.should == ['Testing']
-    P('Testing#mymethod8').tag(:yieldparam).text.should == "the object that the method was called on"
+  it "handles `self` keyword and list object type as yieldparam for _self" do
+    expect(P('Testing#mymethod8').tag(:yield).types).to eq ['_self']
+    expect(P('Testing#mymethod8').tag(:yieldparam).types).to eq ['Testing']
+    expect(P('Testing#mymethod8').tag(:yieldparam).text).to eq "the object that the method was called on"
   end
 
-  it "should handle `super` keyword and document it under _super" do
-    P('Testing#mymethod9').tag(:yield).types.should == ['_super']
-    P('Testing#mymethod9').tag(:yieldparam).types.should be_nil
-    P('Testing#mymethod9').tag(:yieldparam).text.should == "the result of the method from the superclass"
+  it "handles `super` keyword and document it under _super" do
+    expect(P('Testing#mymethod9').tag(:yield).types).to eq ['_super']
+    expect(P('Testing#mymethod9').tag(:yieldparam).types).to be nil
+    expect(P('Testing#mymethod9').tag(:yieldparam).text).to eq "the result of the method from the superclass"
   end
 end