kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Removing miniunit

Browse source 
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19738 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ryan 2008-10-10 00:56:29 +00:00
parent 94355e2984
commit 3e66bda38e
8 changed files with 0 additions and 771 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
lib/mini/mock.rb
View file

@ -1,37 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
class MockExpectationError < StandardError; end
require 'mini/test'
class Mini::Mock
def initialize
@expected_calls = {}
@actual_calls = Hash.new {|h,k| h[k] = [] }
end
def expect(name, retval, args=[])
n, r, a = name, retval, args # for the closure below
@expected_calls[name] = { :retval => retval, :args => args }
self.class.__send__(:define_method, name) { |*x|
raise ArgumentError unless @expected_calls[n][:args].size == x.size
@actual_calls[n] << { :retval => r, :args => x }
retval
}
self
end
def verify
@expected_calls.each_key do |name|
expected = @expected_calls[name]
msg = "expected #{name}, #{expected.inspect}"
raise MockExpectationError, msg unless
@actual_calls.has_key? name and @actual_calls[name].include?(expected)
end
true
end
end

88
lib/mini/spec.rb
View file

@ -1,88 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
#!/usr/bin/ruby -w
require 'mini/test'
class Module
def infect_with_assertions pos_prefix, neg_prefix, skip_re, map = {}
Mini::Assertions.public_instance_methods(false).each do |meth|
meth = meth.to_s
new_name = case meth
when /^assert/ then
meth.sub(/^assert/, pos_prefix.to_s)
when /^refute/ then
meth.sub(/^refute/, neg_prefix.to_s)
end
next unless new_name
next if new_name =~ skip_re
regexp, replacement = map.find { |re, _| new_name =~ re }
new_name.sub! regexp, replacement if replacement
# warn "%-22p -> %p %p" % [meth, new_name, regexp]
self.class_eval <<-EOM
def #{new_name} *args, &block
return Mini::Spec.current.#{meth}(*args, &self) if Proc === self
return Mini::Spec.current.#{meth}(args.first, self) if args.size == 1
return Mini::Spec.current.#{meth}(self, *args)
end
EOM
end
end
end
Object.infect_with_assertions(:must, :wont,
/^(must|wont)$|wont_(throw)|
must_(block|not?_|nothing|raise$)/x,
/(must_throw)s/ => '\1',
/(?!not)_same/ => '_be_same_as',
/_in_/ => '_be_within_',
/_operator/ => '_be',
/_includes/ => '_include',
/(must|wont)_(.*_of|nil|empty)/ => '\1_be_\2',
/must_raises/ => 'must_raise')
class Object
alias :must_be_close_to :must_be_within_delta
alias :wont_be_close_to :wont_be_within_delta
end
module Kernel
def describe desc, &block
cls = Class.new(Mini::Spec)
Object.const_set desc.to_s.split(/\W+/).map { |s| s.capitalize }.join, cls
cls.class_eval(&block)
end
end
class Mini::Spec < Mini::Test::TestCase
def self.current
@@current_spec
end
def initialize name
super
@@current_spec = self
end
def self.before(type = :each, &block)
raise "unsupported before type: #{type}" unless type == :each
define_method :setup, &block
end
def self.after(type = :each, &block)
raise "unsupported after type: #{type}" unless type == :each
define_method :teardown, &block
end
def self.it desc, &block
define_method "test_#{desc.gsub(/\W+/, '_').downcase}", &block
end
end

488
lib/mini/test.rb
View file

@ -1,488 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
##
#
# Totally minimal drop-in replacement for test-unit
#
# TODO: refute -> debunk, prove/rebut, show/deny... lots of possibilities
module Mini
class Assertion < Exception; end
class Skip < Assertion; end
file = if RUBY_VERSION =~ /^1\.9/ then # bt's expanded, but __FILE__ isn't :(
File.expand_path __FILE__
elsif __FILE__ =~ /^[^\.]/ then # assume both relative
require 'pathname'
pwd = Pathname.new Dir.pwd
pn = Pathname.new File.expand_path(__FILE__)
pn = File.join(".", pn.relative_path_from(pwd)) unless pn.relative?
pn.to_s
else # assume both are expanded
__FILE__
end
# './lib' in project dir, or '/usr/local/blahblah' if installed
MINI_DIR = File.dirname(File.dirname(file))
def self.filter_backtrace bt
return ["No backtrace"] unless bt
new_bt = []
bt.each do |line|
break if line.rindex(MINI_DIR, 0)
new_bt << line
end
new_bt = bt.reject { |line| line.rindex(MINI_DIR, 0) } if new_bt.empty?
new_bt = bt.dup if new_bt.empty?
new_bt
end
module Assertions
def mu_pp(obj)
s = obj.inspect
s = s.force_encoding(Encoding.default_external) if defined? Encoding
s
end
def _assertions= n
@_assertions = n
end
def _assertions
@_assertions ||= 0
end
def assert test, msg = nil
msg ||= "Failed assertion, no message given."
self._assertions += 1
unless test then
msg = msg.call if Proc === msg
raise Mini::Assertion, msg
end
true
end
def assert_block msg = nil
msg = message(msg) { "Expected block to return true value" }
assert yield, msg
end
def assert_empty obj, msg = nil
msg = message(msg) { "Expected #{obj.inspect} to be empty" }
assert_respond_to obj, :empty?
assert obj.empty?, msg
end
def assert_equal exp, act, msg = nil
msg = message(msg) { "Expected #{mu_pp(exp)}, not #{mu_pp(act)}" }
assert(exp == act, msg)
end
def assert_in_delta exp, act, delta = 0.001, msg = nil
n = (exp - act).abs
msg = message(msg) { "Expected #{exp} - #{act} (#{n}) to be < #{delta}" }
assert delta > n, msg
end
def assert_in_epsilon a, b, epsilon = 0.001, msg = nil
assert_in_delta a, b, [a, b].min * epsilon, msg
end
def assert_includes collection, obj, msg = nil
msg = message(msg) { "Expected #{mu_pp(collection)} to include #{mu_pp(obj)}" }
assert_respond_to collection, :include?
assert collection.include?(obj), msg
end
def assert_instance_of cls, obj, msg = nil
msg = message(msg) { "Expected #{mu_pp(obj)} to be an instance of #{cls}, not #{obj.class}" }
flip = (Module === obj) && ! (Module === cls) # HACK for specs
obj, cls = cls, obj if flip
assert cls === obj, msg
end
def assert_kind_of cls, obj, msg = nil # TODO: merge with instance_of
msg = message(msg) {
"Expected #{mu_pp(obj)} to be a kind of #{cls}, not #{obj.class}" }
flip = (Module === obj) && ! (Module === cls) # HACK for specs
obj, cls = cls, obj if flip
assert obj.kind_of?(cls), msg
end
def assert_match exp, act, msg = nil
msg = message(msg) { "Expected #{mu_pp(act)} to match #{mu_pp(exp)}" }
assert_respond_to act, :"=~"
(exp = /#{exp}/) if String === exp && String === act
assert act =~ exp, msg
end
def assert_nil obj, msg = nil
msg = message(msg) { "Expected #{mu_pp(obj)} to be nil" }
assert obj.nil?, msg
end
def assert_operator o1, op, o2, msg = nil
msg = message(msg) { "Expected #{mu_pp(o1)} to be #{op} #{mu_pp(o2)}" }
assert o1.__send__(op, o2), msg
end
def assert_raises *exp
msg = String === exp.last ? exp.pop : nil
should_raise = false
begin
yield
should_raise = true
rescue Exception => e
assert_includes(exp, e.class, exception_details(e, "<#{mu_pp(exp)}> exception expected, not"))
return e
end
exp = exp.first if exp.size == 1
flunk "#{mu_pp(exp)} expected but nothing was raised." if should_raise
end
def assert_respond_to obj, meth, msg = nil
msg = message(msg) {
"Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}"
}
flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
obj, meth = meth, obj if flip
assert obj.respond_to?(meth), msg
end
def assert_same exp, act, msg = nil
msg = message(msg) {
data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id]
"Expected %s (0x%x) to be the same as %s (0x%x)" % data
}
assert exp.equal?(act), msg
end
def assert_send send_ary, m = nil
recv, msg, *args = send_ary
m = message(m) {
"Expected #{mu_pp(recv)}.#{msg}(*#{mu_pp(args)}) to return true" }
assert recv.__send__(msg, *args), m
end
def assert_throws sym, msg = nil
default = "Expected #{mu_pp(sym)} to have been thrown"
caught = true
catch(sym) do
begin
yield
rescue ArgumentError => e # 1.9 exception
default += ", not #{e.message.split(/ /).last}"
rescue NameError => e # 1.8 exception
default += ", not #{e.name.inspect}"
end
caught = false
end
assert caught, message(msg) { default }
end
def capture_io
require 'stringio'
orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
captured_stdout, captured_stderr = StringIO.new, StringIO.new
$stdout, $stderr = captured_stdout, captured_stderr
yield
return captured_stdout.string, captured_stderr.string
ensure
$stdout = orig_stdout
$stderr = orig_stderr
end
def exception_details e, msg
"#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{Mini::filter_backtrace(e.backtrace).join("\n")}\n---------------"
end
def flunk msg = nil
msg ||= "Epic Fail!"
assert false, msg
end
def message msg = nil, &default
proc {
if msg then
msg = msg.to_s unless String === msg
msg += '.' unless msg.empty?
msg += "\n#{default.call}."
msg.strip
else
"#{default.call}."
end
}
end
# used for counting assertions
def pass msg = nil
assert true
end
def refute test, msg = nil
msg ||= "Failed refutation, no message given"
not assert(! test, msg)
end
def refute_empty obj, msg = nil
msg = message(msg) { "Expected #{obj.inspect} to not be empty" }
assert_respond_to obj, :empty?
refute obj.empty?, msg
end
def refute_equal exp, act, msg = nil
msg = message(msg) { "Expected #{mu_pp(act)} to not be equal to #{mu_pp(exp)}" }
refute exp == act, msg
end
def refute_in_delta exp, act, delta = 0.001, msg = nil
n = (exp - act).abs
msg = message(msg) { "Expected #{exp} - #{act} (#{n}) to not be < #{delta}" }
refute delta > n, msg
end
def refute_in_epsilon a, b, epsilon = 0.001, msg = nil
refute_in_delta a, b, a * epsilon, msg
end
def refute_includes collection, obj, msg = nil
msg = message(msg) { "Expected #{mu_pp(collection)} to not include #{mu_pp(obj)}" }
assert_respond_to collection, :include?
refute collection.include?(obj), msg
end
def refute_instance_of cls, obj, msg = nil
msg = message(msg) { "Expected #{mu_pp(obj)} to not be an instance of #{cls}" }
flip = (Module === obj) && ! (Module === cls) # HACK for specs
obj, cls = cls, obj if flip
refute cls === obj, msg
end
def refute_kind_of cls, obj, msg = nil # TODO: merge with instance_of
msg = message(msg) { "Expected #{mu_pp(obj)} to not be a kind of #{cls}" }
flip = (Module === obj) && ! (Module === cls) # HACK for specs
obj, cls = cls, obj if flip
refute obj.kind_of?(cls), msg
end
def refute_match exp, act, msg = nil
msg = message(msg) { "Expected #{mu_pp(act)} to not match #{mu_pp(exp)}" }
refute act =~ exp, msg
end
def refute_nil obj, msg = nil
msg = message(msg) { "Expected #{mu_pp(obj)} to not be nil" }
refute obj.nil?, msg
end
def refute_operator o1, op, o2, msg = nil
msg = message(msg) { "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}" }
refute o1.__send__(op, o2), msg
end
def refute_respond_to obj, meth, msg = nil
msg = message(msg) { "Expected #{mu_pp(obj)} to not respond to #{meth}" }
flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
obj, meth = meth, obj if flip
refute obj.respond_to?(meth), msg
end
def refute_same exp, act, msg = nil
msg = message(msg) { "Expected #{mu_pp(act)} to not be the same as #{mu_pp(exp)}" }
refute exp.equal?(act), msg
end
def skip msg = nil
msg ||= "Skipped, no message given"
raise Mini::Skip, msg
end
end
class Test
VERSION = "1.3.0"
attr_accessor :report, :failures, :errors, :skips
attr_accessor :test_count, :assertion_count
@@installed_at_exit ||= false
@@out = $stdout
def self.autorun
at_exit {
exit_code = Mini::Test.new.run(ARGV)
exit false if exit_code && exit_code != 0
} unless @@installed_at_exit
@@installed_at_exit = true
end
def self.output= stream
@@out = stream
end
def location e
e.backtrace.find { |s|
s !~ /in .(assert|refute|flunk|pass|fail|raise)/
}.sub(/:in .*$/, '')
end
def puke klass, meth, e
e = case e
when Mini::Skip then
@skips += 1
"Skipped:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
when Mini::Assertion then
@failures += 1
"Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
else
@errors += 1
bt = Mini::filter_backtrace(e.backtrace).join("\n ")
"Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n #{bt}\n"
end
@report << e
e[0, 1]
end
def initialize
@report = []
@errors = @failures = @skips = 0
@verbose = false
end
##
# Top level driver, controls all output and filtering.
def run args = []
@verbose = args.delete('-v')
filter = if args.first =~ /^(-n|--name)$/ then
args.shift
arg = args.shift
arg =~ /\/(.*)\// ? Regexp.new($1) : arg
else
/./ # anything - ^test_ already filtered by #tests
end
@@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
start = Time.now
run_test_suites filter
@@out.puts
@@out.puts "Finished in #{'%.6f' % (Time.now - start)} seconds."
@report.each_with_index do |msg, i|
@@out.puts "\n%3d) %s" % [i + 1, msg]
end
@@out.puts
format = "%d tests, %d assertions, %d failures, %d errors, %d skips"
@@out.puts format % [test_count, assertion_count, failures, errors, skips]
return failures + errors if @test_count > 0 # or return nil...
end
def run_test_suites filter = /./
@test_count, @assertion_count = 0, 0
old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
TestCase.test_suites.each do |suite|
suite.test_methods.grep(filter).each do |test|
inst = suite.new test
inst._assertions = 0
@@out.print "#{suite}##{test}: " if @verbose
t = Time.now if @verbose
result = inst.run(self)
@@out.print "%.2f s: " % (Time.now - t) if @verbose
@@out.print result
@@out.puts if @verbose
@test_count += 1
@assertion_count += inst._assertions
end
end
@@out.sync = old_sync if @@out.respond_to? :sync=
[@test_count, @assertion_count]
end
class TestCase
attr_reader :name
def run runner
result = '.'
begin
@passed = nil
self.setup
self.__send__ self.name
@passed = true
rescue Exception => e
@passed = false
result = runner.puke(self.class, self.name, e)
ensure
begin
self.teardown
rescue Exception => e
result = runner.puke(self.class, self.name, e)
end
end
result
end
def initialize name
@name = name
@passed = nil
end
def self.reset
@@test_suites = {}
end
reset
def self.inherited klass
@@test_suites[klass] = true
end
def self.test_order
:random
end
def self.test_suites
@@test_suites.keys.sort_by { |ts| ts.name }
end
def self.test_methods
methods = public_instance_methods(true).grep(/^test/).map { |m|
m.to_s
}.sort
if self.test_order == :random then
max = methods.size
methods = methods.sort_by { rand(max) }
end
methods
end
def setup; end
def teardown; end
def passed?
@passed
end
include Mini::Assertions
end # class TestCase
end # class Test
end # module Mini

10
lib/test/unit.rb
View file

@ -1,10 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
require 'mini/test'
require 'test/unit/testcase' # pull in deprecated functionality
Mini::Test.autorun

70
lib/test/unit/assertions.rb
View file

@ -1,70 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
require 'mini/test'
module Test; end
module Test::Unit # patch up bastards that that extend improperly.
if defined? Assertions then
warn "ARGH! someone defined Test::Unit::Assertions rather than requiring"
CRAP_ASSERTIONS = Assertions
remove_const :Assertions
# this will break on junit and rubinius... *sigh*
ObjectSpace.each_object(Module) do |offender|
offender.send :include, ::Mini::Assertions if offender < CRAP_ASSERTIONS
end rescue nil
Test::Unit::TestCase.send :include, CRAP_ASSERTIONS
end
Assertions = ::Mini::Assertions
module Assertions
def self.included mod
mod.send :include, Test::Unit::CRAP_ASSERTIONS
end if defined? Test::Unit::CRAP_ASSERTIONS
end
end
module Test::Unit
module Assertions
def assert_nothing_raised(*exp)
msg = (Module === exp.last) ? "" : exp.pop
noexc = exp.select {|e| not (Module === e and Exception >= e)}
unless noexc.empty?
noexc = *noexc if noexc.size == 1
raise TypeError, "Should expect a class of exception, #{noexc.inspect}"
end
self._assertions += 1
begin
yield
rescue Exception => e
exp.include?(e.class) or raise
raise(Mini::Assertion, exception_details(e, "#{msg}#{msg.empty? ? '' : ' '}Exception raised:"))
end
end
def build_message(user_message, template_message, *args)
user_message ||= ''
user_message += ' ' unless user_message.empty?
msg = template_message.split(/<\?>/).zip(args.map { |o| o.inspect })
user_message + msg.join
end
alias assert_nothing_thrown assert_nothing_raised
alias assert_raise assert_raises
alias assert_not_equal refute_equal
alias assert_no_match refute_match
alias assert_not_nil refute_nil
alias assert_not_same refute_same
private
def _wrap_assertion
yield
end
end
end

30
lib/test/unit/deprecate.rb
View file

@ -1,30 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
class Module # define deprecation api
DEPS = Hash.new { |h,k| h[k] = {} }
def tu_deprecation_warning old, new = nil, kaller = nil
kaller ||= caller[1]
unless DEPS[old][kaller] then
msg = "#{self}##{old} deprecated. "
msg += new ? "Use ##{new}" : "No replacement is provided"
msg += ". From #{kaller}."
warn msg
end
DEPS[old][kaller] = true
end
def tu_deprecate old, new
class_eval <<-EOM
def #{old} *args, &block
cls, clr = self.class, caller.first
self.class.tu_deprecation_warning #{old.inspect}, #{new.inspect}, clr
#{new}(*args, &block)
end
EOM
end
end

17
lib/test/unit/error.rb
View file

@ -1,17 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
require 'test/unit/deprecate'
# rails currently needs this file and this one method.
module Test::Unit
class Error
def message
self.class.tu_deprecation_warning :message # 2009-06-01
"you're a loser"
end
end
end

31
lib/test/unit/testcase.rb
View file

@ -1,31 +0,0 @@
############################################################
# This file is imported from a different project.
# DO NOT make modifications in this repo.
# File a patch instead and assign it to Ryan Davis
############################################################
require 'mini/test'
require 'test/unit/deprecate'
warn "require 'test/unit/testcase' has been deprecated" unless
caller.first =~ /test.unit.rb/
module Test; end
module Test::Unit # was ::Mini::Test, but rails' horrid code forced my hand
if defined? TestCase then
warn "ARGH! someone defined Test::Unit::TestCase rather than requiring"
remove_const :TestCase
end
AssertionFailedError = ::Mini::Assertion
class TestCase < ::Mini::Test::TestCase
tu_deprecate :method_name, :name # 2009-06-01
def self.test_order # 2009-06-01
:sorted
end
end
end
require 'test/unit/assertions' # brings in deprecated methods