C0 code coverage information

Generated on Mon Aug 13 01:18:54 -0400 2007 with rcov 0.8.0

Code reported as executed by Ruby looks like this...
and this: this line is also marked as covered.
Lines considered as run by rcov, but not reported by Ruby, look like this,
and this: these lines were inferred by rcov (using simple heuristics).
Finally, here's a line marked as not executed.

  1 module Spec
  2   module Matchers
  3     
  4     class RaiseError #:nodoc:
  5       def initialize(error_or_message=Exception, message=nil)
  6         if String === error_or_message
  7           @expected_error = Exception
  8           @expected_message = error_or_message
  9         else
 10           @expected_error = error_or_message
 11           @expected_message = message
 12         end
 13       end
 14       
 15       def matches?(proc)
 16         @raised_expected_error = false
 17         @raised_other = false
 18         begin
 19           proc.call
 20         rescue @expected_error => @actual_error
 21           if @expected_message.nil?
 22             @raised_expected_error = true
 23           else
 24             case @expected_message
 25             when Regexp
 26               if @expected_message =~ @actual_error.message
 27                 @raised_expected_error = true
 28               else
 29                 @raised_other = true
 30               end
 31             else
 32               if @expected_message == @actual_error.message
 33                 @raised_expected_error = true
 34               else
 35                 @raised_other = true
 36               end
 37             end
 38           end
 39         rescue => @actual_error
 40           @raised_other = true
 41         ensure
 42           return @raised_expected_error
 43         end
 44       end
 45       
 46       def failure_message
 47         return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
 48       end
 49 
 50       def negative_failure_message
 51         "expected no #{expected_error}#{actual_error}"
 52       end
 53       
 54       def description
 55         "raise #{expected_error}"
 56       end
 57       
 58       private
 59         def expected_error
 60           case @expected_message
 61           when nil
 62             @expected_error
 63           when Regexp
 64             "#{@expected_error} with message matching #{@expected_message.inspect}"
 65           else
 66             "#{@expected_error} with #{@expected_message.inspect}"
 67           end
 68         end
 69 
 70         def actual_error
 71           @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
 72         end
 73     end
 74     
 75     # :call-seq:
 76     #   should raise_error()
 77     #   should raise_error(NamedError)
 78     #   should raise_error(NamedError, String)
 79     #   should raise_error(NamedError, Regexp)
 80     #   should_not raise_error()
 81     #   should_not raise_error(NamedError)
 82     #   should_not raise_error(NamedError, String)
 83     #   should_not raise_error(NamedError, Regexp)
 84     #
 85     # With no args, matches if any error is raised.
 86     # With a named error, matches only if that specific error is raised.
 87     # With a named error and messsage specified as a String, matches only if both match.
 88     # With a named error and messsage specified as a Regexp, matches only if both match.
 89     #
 90     # == Examples
 91     #
 92     #   lambda { do_something_risky }.should raise_error
 93     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
 94     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
 95     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
 96     #
 97     #   lambda { do_something_risky }.should_not raise_error
 98     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
 99     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
100     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
101     def raise_error(error=Exception, message=nil)
102       Matchers::RaiseError.new(error, message)
103     end
104   end
105 end

Generated using the rcov code coverage analysis tool for Ruby version 0.8.0.