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

* lib/test: Removed because ruby's test cases now independent to

Browse source 
lib/test by r45970. [Feature #9711] [ruby-core:62620]

  I'm still considering about the future of lib/minitest, lib/test.
  (bundling gems?)

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@45974 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
sorah 2014-05-17 08:01:15 +00:00
parent 59cb82c52c
commit 96f552670d
6 changed files with 8 additions and 1582 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
ChangeLog
View file

@ -1,3 +1,11 @@
Sat May 17 16:57:33 2014 Shota Fukumori <her@sorah.jp>
* lib/test: Removed because ruby's test cases now independent to
lib/test by r45970. [Feature #9711] [ruby-core:62620]
I'm still considering about the future of lib/minitest, lib/test.
(bundling gems?)
Sat May 17 15:06:40 2014 SHIBATA Hiroshi <shibata.hiroshi@gmail.com>
* test/runner.rb: remove dependency test-unit and minitest

880
lib/test/unit.rb
View file

@ -1,880 +0,0 @@
begin
gem 'minitest', '< 5.0.0' if defined? Gem
rescue Gem::LoadError
end
require 'minitest/unit'
require 'test/unit/assertions'
require 'test/unit/testcase'
require 'optparse'
# See Test::Unit
module Test
##
# Test::Unit is an implementation of the xUnit testing framework for Ruby.
#
# If you are writing new test code, please use MiniTest instead of Test::Unit.
#
# Test::Unit has been left in the standard library to support legacy test
# suites.
module Unit
TEST_UNIT_IMPLEMENTATION = 'test/unit compatibility layer using minitest' # :nodoc:
module RunCount # :nodoc: all
@@run_count = 0
def self.have_run?
@@run_count.nonzero?
end
def run(*)
@@run_count += 1
super
end
def run_once
return if have_run?
return if $! # don't run if there was an exception
yield
end
module_function :run_once
end
module Options # :nodoc: all
def initialize(*, &block)
@init_hook = block
@options = nil
super(&nil)
end
def option_parser
@option_parser ||= OptionParser.new
end
def process_args(args = [])
return @options if @options
orig_args = args.dup
options = {}
opts = option_parser
setup_options(opts, options)
opts.parse!(args)
orig_args -= args
args = @init_hook.call(args, options) if @init_hook
non_options(args, options)
@help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "
@options = options
if @options[:parallel]
@files = args
@args = orig_args
end
options
end
private
def setup_options(opts, options)
opts.separator 'minitest options:'
opts.version = MiniTest::Unit::VERSION
options[:retry] = true
options[:job_status] = nil
opts.on '-h', '--help', 'Display this help.' do
puts opts
exit
end
opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
options[:seed] = m
end
opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
options[:verbose] = true
self.verbose = options[:verbose]
end
opts.on '-n', '--name PATTERN', "Filter test names on pattern." do |a|
options[:filter] = a
end
opts.on '--jobs-status [TYPE]', [:normal, :replace],
"Show status of jobs every file; Disabled when --jobs isn't specified." do |type|
options[:job_status] = type || :normal
end
opts.on '-j N', '--jobs N', "Allow run tests with N jobs at once" do |a|
if /^t/ =~ a
options[:testing] = true # For testing
options[:parallel] = a[1..-1].to_i
else
options[:parallel] = a.to_i
end
end
opts.on '--separate', "Restart job process after one testcase has done" do
options[:parallel] ||= 1
options[:separate] = true
end
opts.on '--retry', "Retry running testcase when --jobs specified" do
options[:retry] = true
end
opts.on '--no-retry', "Disable --retry" do
options[:retry] = false
end
opts.on '--ruby VAL', "Path to ruby; It'll have used at -j option" do |a|
options[:ruby] = a.split(/ /).reject(&:empty?)
end
opts.on '-q', '--hide-skip', 'Hide skipped tests' do
options[:hide_skip] = true
end
opts.on '--show-skip', 'Show skipped tests' do
options[:hide_skip] = false
end
opts.on '--color[=WHEN]',
[:always, :never, :auto],
"colorize the output. WHEN defaults to 'always'", "or can be 'never' or 'auto'." do |c|
options[:color] = c || :always
end
opts.on '--tty[=WHEN]',
[:yes, :no],
"force to output tty control. WHEN defaults to 'yes'", "or can be 'no'." do |c|
@tty = c != :no
end
end
def non_options(files, options)
begin
require "rbconfig"
rescue LoadError
warn "#{caller(1)[0]}: warning: Parallel running disabled because can't get path to ruby; run specify with --ruby argument"
options[:parallel] = nil
else
options[:ruby] ||= [RbConfig.ruby]
end
true
end
end
module GlobOption # :nodoc: all
@@testfile_prefix = "test"
def setup_options(parser, options)
super
parser.on '-b', '--basedir=DIR', 'Base directory of test suites.' do |dir|
options[:base_directory] = dir
end
parser.on '-x', '--exclude PATTERN', 'Exclude test files on pattern.' do |pattern|
(options[:reject] ||= []) << pattern
end
end
def non_options(files, options)
paths = [options.delete(:base_directory), nil].uniq
if reject = options.delete(:reject)
reject_pat = Regexp.union(reject.map {|r| /#{r}/ })
end
files.map! {|f|
f = f.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
((paths if /\A\.\.?(?:\z|\/)/ !~ f) || [nil]).any? do |prefix|
if prefix
path = f.empty? ? prefix : "#{prefix}/#{f}"
else
next if f.empty?
path = f
end
if !(match = Dir["#{path}/**/#{@@testfile_prefix}_*.rb"]).empty?
if reject
match.reject! {|n|
n[(prefix.length+1)..-1] if prefix
reject_pat =~ n
}
end
break match
elsif !reject or reject_pat !~ f and File.exist? path
break path
end
end or
raise ArgumentError, "file not found: #{f}"
}
files.flatten!
super(files, options)
end
end
module LoadPathOption # :nodoc: all
def setup_options(parser, options)
super
parser.on '-Idirectory', 'Add library load path' do |dirs|
dirs.split(':').each { |d| $LOAD_PATH.unshift d }
end
end
end
module GCStressOption # :nodoc: all
def setup_options(parser, options)
super
parser.on '--[no-]gc-stress', 'Set GC.stress as true' do |flag|
options[:gc_stress] = flag
end
end
def non_options(files, options)
if options.delete(:gc_stress)
MiniTest::Unit::TestCase.class_eval do
oldrun = instance_method(:run)
define_method(:run) do |runner|
begin
gc_stress, GC.stress = GC.stress, true
oldrun.bind(self).call(runner)
ensure
GC.stress = gc_stress
end
end
end
end
super
end
end
module RequireFiles # :nodoc: all
def non_options(files, options)
return false if !super
result = false
files.each {|f|
d = File.dirname(path = File.realpath(f))
unless $:.include? d
$: << d
end
begin
require path unless options[:parallel]
result = true
rescue LoadError
puts "#{f}: #{$!}"
end
}
result
end
end
class Runner < MiniTest::Unit # :nodoc: all
include Test::Unit::Options
include Test::Unit::GlobOption
include Test::Unit::LoadPathOption
include Test::Unit::GCStressOption
include Test::Unit::RunCount
class Worker
def self.launch(ruby,args=[])
io = IO.popen([*ruby,
"#{File.dirname(__FILE__)}/unit/parallel.rb",
*args], "rb+")
new(io, io.pid, :waiting)
end
attr_reader :quit_called
def initialize(io, pid, status)
@io = io
@pid = pid
@status = status
@file = nil
@real_file = nil
@loadpath = []
@hooks = {}
@quit_called = false
end
def puts(*args)
@io.puts(*args)
end
def run(task,type)
@file = File.basename(task, ".rb")
@real_file = task
begin
puts "loadpath #{[Marshal.dump($:-@loadpath)].pack("m0")}"
@loadpath = $:.dup
puts "run #{task} #{type}"
@status = :prepare
rescue Errno::EPIPE
died
rescue IOError
raise unless ["stream closed","closed stream"].include? $!.message
died
end
end
def hook(id,&block)
@hooks[id] ||= []
@hooks[id] << block
self
end
def read
res = (@status == :quit) ? @io.read : @io.gets
res && res.chomp
end
def close
@io.close unless @io.closed?
self
rescue IOError
end
def quit
return if @io.closed?
@quit_called = true
@io.puts "quit"
@io.close
end
def kill
Process.kill(:KILL, @pid)
rescue Errno::ESRCH
end
def died(*additional)
@status = :quit
@io.close
call_hook(:dead,*additional)
end
def to_s
if @file
"#{@pid}=#{@file}"
else
"#{@pid}:#{@status.to_s.ljust(7)}"
end
end
attr_reader :io, :pid
attr_accessor :status, :file, :real_file, :loadpath
private
def call_hook(id,*additional)
@hooks[id] ||= []
@hooks[id].each{|hook| hook[self,additional] }
self
end
end
class << self; undef autorun; end
@@stop_auto_run = false
def self.autorun
at_exit {
Test::Unit::RunCount.run_once {
exit(Test::Unit::Runner.new.run(ARGV) || true)
} unless @@stop_auto_run
} unless @@installed_at_exit
@@installed_at_exit = true
end
def after_worker_down(worker, e=nil, c=false)
return unless @options[:parallel]
return if @interrupt
warn e if e
@need_quit = true
warn ""
warn "Some worker was crashed. It seems ruby interpreter's bug"
warn "or, a bug of test/unit/parallel.rb. try again without -j"
warn "option."
warn ""
STDERR.flush
exit c
end
def terminal_width
unless @terminal_width ||= nil
begin
require 'io/console'
width = $stdout.winsize[1]
rescue LoadError, NoMethodError, Errno::ENOTTY, Errno::EBADF
width = ENV["COLUMNS"].to_i.nonzero? || 80
end
width -= 1 if /mswin|mingw/ =~ RUBY_PLATFORM
@terminal_width = width
end
@terminal_width
end
def del_status_line
@status_line_size ||= 0
unless @options[:job_status] == :replace
$stdout.puts
return
end
print "\r"+" "*@status_line_size+"\r"
$stdout.flush
@status_line_size = 0
end
def put_status(line)
unless @options[:job_status] == :replace
print(line)
return
end
@status_line_size ||= 0
del_status_line
$stdout.flush
line = line[0...terminal_width]
print line
$stdout.flush
@status_line_size = line.size
end
def add_status(line)
unless @options[:job_status] == :replace
print(line)
return
end
@status_line_size ||= 0
line = line[0...(terminal_width-@status_line_size)]
print line
$stdout.flush
@status_line_size += line.size
end
def jobs_status
return unless @options[:job_status]
puts "" unless @options[:verbose] or @options[:job_status] == :replace
status_line = @workers.map(&:to_s).join(" ")
update_status(status_line) or (puts; nil)
end
def del_jobs_status
return unless @options[:job_status] == :replace && @status_line_size.nonzero?
del_status_line
end
def after_worker_quit(worker)
return unless @options[:parallel]
return if @interrupt
@workers.delete(worker)
@dead_workers << worker
@ios = @workers.map(&:io)
end
def launch_worker
begin
worker = Worker.launch(@options[:ruby],@args)
rescue => e
abort "ERROR: Failed to launch job process - #{e.class}: #{e.message}"
end
worker.hook(:dead) do |w,info|
after_worker_quit w
after_worker_down w, *info if !info.empty? && !worker.quit_called
end
@workers << worker
@ios << worker.io
@workers_hash[worker.io] = worker
worker
end
def delete_worker(worker)
@workers_hash.delete worker.io
@workers.delete worker
@ios.delete worker.io
end
def quit_workers
return if @workers.empty?
@workers.reject! do |worker|
begin
timeout(1) do
worker.quit
end
rescue Errno::EPIPE
rescue Timeout::Error
end
worker.close
end
return if @workers.empty?
begin
timeout(0.2 * @workers.size) do
Process.waitall
end
rescue Timeout::Error
@workers.each do |worker|
worker.kill
end
@worker.clear
end
end
def start_watchdog
Thread.new do
while stat = Process.wait2
break if @interrupt # Break when interrupt
pid, stat = stat
w = (@workers + @dead_workers).find{|x| pid == x.pid }
next unless w
w = w.dup
if w.status != :quit && !w.quit_called?
# Worker down
w.died(nil, !stat.signaled? && stat.exitstatus)
end
end
end
end
def deal(io, type, result, rep, shutting_down = false)
worker = @workers_hash[io]
case worker.read
when /^okay$/
worker.status = :running
jobs_status
when /^ready(!)?$/
bang = $1
worker.status = :ready
return nil unless task = @tasks.shift
if @options[:separate] and not bang
worker.quit
worker = add_worker
end
worker.run(task, type)
@test_count += 1
jobs_status
when /^done (.+?)$/
r = Marshal.load($1.unpack("m")[0])
result << r[0..1] unless r[0..1] == [nil,nil]
rep << {file: worker.real_file, report: r[2], result: r[3], testcase: r[5]}
$:.push(*r[4]).uniq!
return true
when /^p (.+?)$/
del_jobs_status
print $1.unpack("m")[0]
jobs_status if @options[:job_status] == :replace
when /^after (.+?)$/
@warnings << Marshal.load($1.unpack("m")[0])
when /^bye (.+?)$/
after_worker_down worker, Marshal.load($1.unpack("m")[0])
when /^bye$/, nil
if shutting_down || worker.quit_called
after_worker_quit worker
else
after_worker_down worker
end
end
return false
end
def _run_parallel suites, type, result
if @options[:parallel] < 1
warn "Error: parameter of -j option should be greater than 0."
return
end
# Require needed things for parallel running
require 'thread'
require 'timeout'
@tasks = @files.dup # Array of filenames.
@need_quit = false
@dead_workers = [] # Array of dead workers.
@warnings = []
@total_tests = @tasks.size.to_s(10)
rep = [] # FIXME: more good naming
@workers = [] # Array of workers.
@workers_hash = {} # out-IO => worker
@ios = [] # Array of worker IOs
begin
# Thread: watchdog
watchdog = start_watchdog
@options[:parallel].times {launch_worker}
while _io = IO.select(@ios)[0]
break if _io.any? do |io|
@need_quit or
(deal(io, type, result, rep).nil? and
!@workers.any? {|x| [:running, :prepare].include? x.status})
end
end
rescue Interrupt => ex
@interrupt = ex
return result
ensure
watchdog.kill if watchdog
if @interrupt
@ios.select!{|x| @workers_hash[x].status == :running }
while !@ios.empty? && (__io = IO.select(@ios,[],[],10))
__io[0].reject! {|io| deal(io, type, result, rep, true)}
end
end
quit_workers
unless @interrupt || !@options[:retry] || @need_quit
@options[:parallel] = false
suites, rep = rep.partition {|r| r[:testcase] && r[:file] && r[:report].any? {|e| !e[2].is_a?(MiniTest::Skip)}}
suites.map {|r| r[:file]}.uniq.each {|file| require file}
suites.map! {|r| eval("::"+r[:testcase])}
del_status_line or puts
unless suites.empty?
puts "Retrying..."
_run_suites(suites, type)
end
end
unless @options[:retry]
del_status_line or puts
end
unless rep.empty?
rep.each do |r|
r[:report].each do |f|
puke(*f) if f
end
end
if @options[:retry]
@errors += rep.map{|x| x[:result][0] }.inject(:+)
@failures += rep.map{|x| x[:result][1] }.inject(:+)
@skips += rep.map{|x| x[:result][2] }.inject(:+)
end
end
unless @warnings.empty?
warn ""
@warnings.uniq! {|w| w[1].message}
@warnings.each do |w|
warn "#{w[0]}: #{w[1].message} (#{w[1].class})"
end
warn ""
end
end
end
def _run_suites suites, type
_prepare_run(suites, type)
@interrupt = nil
result = []
GC.start
if @options[:parallel]
_run_parallel suites, type, result
else
suites.each {|suite|
begin
result << _run_suite(suite, type)
rescue Interrupt => e
@interrupt = e
break
end
}
end
report.reject!{|r| r.start_with? "Skipped:" } if @options[:hide_skip]
report.sort_by!{|r| r.start_with?("Skipped:") ? 0 : \
(r.start_with?("Failure:") ? 1 : 2) }
result
end
alias mini_run_suite _run_suite
def output
(@output ||= nil) || super
end
def _prepare_run(suites, type)
options[:job_status] ||= :replace if @tty && !@verbose
case options[:color]
when :always
color = true
when :auto, nil
color = @options[:job_status] == :replace && /dumb/ !~ ENV["TERM"]
else
color = false
end
if color
# dircolors-like style
colors = (colors = ENV['TEST_COLORS']) ? Hash[colors.scan(/(\w+)=([^:]*)/)] : {}
@passed_color = "\e[#{colors["pass"] || "32"}m"
@failed_color = "\e[#{colors["fail"] || "31"}m"
@skipped_color = "\e[#{colors["skip"] || "33"}m"
@reset_color = "\e[m"
else
@passed_color = @failed_color = @skipped_color = @reset_color = ""
end
if color or @options[:job_status] == :replace
@verbose = !options[:parallel]
@output = StatusLineOutput.new(self)
end
if /\A\/(.*)\/\z/ =~ (filter = options[:filter])
filter = Regexp.new($1)
end
type = "#{type}_methods"
total = if filter
suites.inject(0) {|n, suite| n + suite.send(type).grep(filter).size}
else
suites.inject(0) {|n, suite| n + suite.send(type).size}
end
@test_count = 0
@total_tests = total.to_s(10)
end
def new_test(s)
@test_count += 1
update_status(s)
end
def update_status(s)
count = @test_count.to_s(10).rjust(@total_tests.size)
put_status("#{@passed_color}[#{count}/#{@total_tests}]#{@reset_color} #{s}")
end
def _print(s); $stdout.print(s); end
def succeed; del_status_line; end
def failed(s)
sep = "\n"
@report_count ||= 0
report.each do |msg|
if msg.start_with? "Skipped:"
if @options[:hide_skip]
del_status_line
next
end
color = @skipped_color
else
color = @failed_color
end
msg = msg.split(/$/, 2)
$stdout.printf("%s%s%3d) %s%s%s\n",
sep, color, @report_count += 1,
msg[0], @reset_color, msg[1])
sep = nil
end
report.clear
end
# Overriding of MiniTest::Unit#puke
def puke klass, meth, e
# TODO:
# this overriding is for minitest feature that skip messages are
# hidden when not verbose (-v), note this is temporally.
n = report.size
rep = super
if MiniTest::Skip === e and /no message given\z/ =~ e.message
report.slice!(n..-1)
rep = "."
end
rep
end
def initialize
super
@tty = $stdout.tty?
end
def status(*args)
result = super
raise @interrupt if @interrupt
result
end
def run(*args)
result = super
puts "\nruby -v: #{RUBY_DESCRIPTION}"
result
end
end
class StatusLineOutput < Struct.new(:runner) # :nodoc: all
def puts(*a) $stdout.puts(*a) unless a.empty? end
def respond_to_missing?(*a) $stdout.respond_to?(*a) end
def method_missing(*a, &b) $stdout.__send__(*a, &b) end
def print(s)
case s
when /\A(.*\#.*) = \z/
runner.new_test($1)
when /\A(.* s) = \z/
runner.add_status(" = "+$1.chomp)
when /\A\.+\z/
runner.succeed
when /\A[EFS]\z/
runner.failed(s)
else
$stdout.print(s)
end
end
end
class AutoRunner # :nodoc: all
class Runner < Test::Unit::Runner
include Test::Unit::RequireFiles
end
attr_accessor :to_run, :options
def initialize(force_standalone = false, default_dir = nil, argv = ARGV)
@force_standalone = force_standalone
@runner = Runner.new do |files, options|
options[:base_directory] ||= default_dir
files << default_dir if files.empty? and default_dir
@to_run = files
yield self if block_given?
files
end
Runner.runner = @runner
@options = @runner.option_parser
if @force_standalone
@options.banner.sub!(/\[options\]/, '\& tests...')
end
@argv = argv
end
def process_args(*args)
@runner.process_args(*args)
!@to_run.empty?
end
def run
if @force_standalone and not process_args(@argv)
abort @options.banner
end
@runner.run(@argv) || true
end
def self.run(*args)
new(*args).run
end
end
class ProxyError < StandardError # :nodoc: all
def initialize(ex)
@message = ex.message
@backtrace = ex.backtrace
end
attr_accessor :message, :backtrace
end
end
end
module MiniTest # :nodoc: all
class Unit
end
end
class MiniTest::Unit::TestCase # :nodoc: all
undef run_test
RUN_TEST_TRACE = "#{__FILE__}:#{__LINE__+3}:in `run_test'".freeze
def run_test(name)
progname, $0 = $0, "#{$0}: #{self.class}##{name}"
self.__send__(name)
ensure
$@.delete(RUN_TEST_TRACE) if $@
$0 = progname
end
end
Test::Unit::Runner.autorun

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

@ -1,461 +0,0 @@
require 'minitest/unit'
require 'pp'
module Test
module Unit
module Assertions
include MiniTest::Assertions
def mu_pp(obj) #:nodoc:
obj.pretty_inspect.chomp
end
MINI_DIR = File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), "minitest") #:nodoc:
# :call-seq:
# assert(test, [failure_message])
#
#Tests if +test+ is true.
#
#+msg+ may be a String or a Proc. If +msg+ is a String, it will be used
#as the failure message. Otherwise, the result of calling +msg+ will be
#used as the message if the assertion fails.
#
#If no +msg+ is given, a default message will be used.
#
# assert(false, "This was expected to be true")
def assert(test, *msgs)
case msg = msgs.first
when String, Proc
when nil
msgs.shift
else
bt = caller.reject { |s| s.start_with?(MINI_DIR) }
raise ArgumentError, "assertion message must be String or Proc, but #{msg.class} was given.", bt
end unless msgs.empty?
super
end
# :call-seq:
# assert_block( failure_message = nil )
#
#Tests the result of the given block. If the block does not return true,
#the assertion will fail. The optional +failure_message+ argument is the same as in
#Assertions#assert.
#
# assert_block do
# [1, 2, 3].any? { |num| num < 1 }
# end
def assert_block(*msgs)
assert yield, *msgs
end
# :call-seq:
# assert_raise( *args, &block )
#
#Tests if the given block raises an exception. Acceptable exception
#types may be given as optional arguments. If the last argument is a
#String, it will be used as the error message.
#
# assert_raise do #Fails, no Exceptions are raised
# end
#
# assert_raise NameError do
# puts x #Raises NameError, so assertion succeeds
# end
def assert_raise(*exp, &b)
case exp.last
when String, Proc
msg = exp.pop
end
begin
yield
rescue MiniTest::Skip => e
return e if exp.include? MiniTest::Skip
raise e
rescue Exception => e
expected = exp.any? { |ex|
if ex.instance_of? Module then
e.kind_of? ex
else
e.instance_of? ex
end
}
assert expected, proc {
exception_details(e, message(msg) {"#{mu_pp(exp)} exception expected, not"}.call)
}
return e
end
exp = exp.first if exp.size == 1
flunk(message(msg) {"#{mu_pp(exp)} expected but nothing was raised"})
end
# :call-seq:
# assert_raise_with_message(exception, expected, msg = nil, &block)
#
#Tests if the given block raises an exception with the expected
#message.
#
# assert_raise_with_message(RuntimeError, "foo") do
# nil #Fails, no Exceptions are raised
# end
#
# assert_raise_with_message(RuntimeError, "foo") do
# raise ArgumentError, "foo" #Fails, different Exception is raised
# end
#
# assert_raise_with_message(RuntimeError, "foo") do
# raise "bar" #Fails, RuntimeError is raised but the message differs
# end
#
# assert_raise_with_message(RuntimeError, "foo") do
# raise "foo" #Raises RuntimeError with the message, so assertion succeeds
# end
def assert_raise_with_message(exception, expected, msg = nil, &block)
case expected
when String
assert = :assert_equal
when Regexp
assert = :assert_match
else
raise TypeError, "Expected #{expected.inspect} to be a kind of String or Regexp, not #{expected.class}"
end
ex = assert_raise(exception, *msg) {yield}
msg = message(msg, "") {"Expected Exception(#{exception}) was raised, but the message doesn't match"}
if assert == :assert_equal
assert_equal(expected, ex.message, msg)
else
msg = message(msg) { "Expected #{mu_pp expected} to match #{mu_pp ex.message}" }
assert expected =~ ex.message, msg
block.binding.eval("proc{|_|$~=_}").call($~)
end
ex
end
# :call-seq:
# assert_nothing_raised( *args, &block )
#
#If any exceptions are given as arguments, the assertion will
#fail if one of those exceptions are raised. Otherwise, the test fails
#if any exceptions are raised.
#
#The final argument may be a failure message.
#
# assert_nothing_raised RuntimeError do
# raise Exception #Assertion passes, Exception is not a RuntimeError
# end
#
# assert_nothing_raised do
# raise Exception #Assertion fails
# end
def assert_nothing_raised(*args)
self._assertions += 1
if Module === args.last
msg = nil
else
msg = args.pop
end
begin
line = __LINE__; yield
rescue MiniTest::Skip
raise
rescue Exception => e
bt = e.backtrace
as = e.instance_of?(MiniTest::Assertion)
if as
ans = /\A#{Regexp.quote(__FILE__)}:#{line}:in /o
bt.reject! {|ln| ans =~ ln}
end
if ((args.empty? && !as) ||
args.any? {|a| a.instance_of?(Module) ? e.is_a?(a) : e.class == a })
msg = message(msg) { "Exception raised:\n<#{mu_pp(e)}>" }
raise MiniTest::Assertion, msg.call, bt
else
raise
end
end
nil
end
# :call-seq:
# assert_nothing_thrown( failure_message = nil, &block )
#
#Fails if the given block uses a call to Kernel#throw, and
#returns the result of the block otherwise.
#
#An optional failure message may be provided as the final argument.
#
# assert_nothing_thrown "Something was thrown!" do
# throw :problem?
# end
def assert_nothing_thrown(msg=nil)
begin
ret = yield
rescue ArgumentError => error
raise error if /\Auncaught throw (.+)\z/m !~ error.message
msg = message(msg) { "<#{$1}> was thrown when nothing was expected" }
flunk(msg)
end
assert(true, "Expected nothing to be thrown")
ret
end
# :call-seq:
# assert_throw( tag, failure_message = nil, &block )
#
#Fails unless the given block throws +tag+, returns the caught
#value otherwise.
#
#An optional failure message may be provided as the final argument.
#
# tag = Object.new
# assert_throw(tag, "#{tag} was not thrown!") do
# throw tag
# end
def assert_throw(tag, msg = nil)
ret = catch(tag) do
begin
yield(tag)
rescue ArgumentError => e
raise unless thrown = e.message[/\Auncaught throw (.+)\z/m, 1]
end
msg = message(msg) {
"Expected #{mu_pp(tag)} to have been thrown"\
"#{", not #{thrown}" if thrown}"
}
assert(false, msg)
end
assert(true)
ret
end
# :call-seq:
# assert_equal( expected, actual, failure_message = nil )
#
#Tests if +expected+ is equal to +actual+.
#
#An optional failure message may be provided as the final argument.
def assert_equal(exp, act, msg = nil)
msg = message(msg) {
exp_str = mu_pp(exp)
act_str = mu_pp(act)
exp_comment = ''
act_comment = ''
if exp_str == act_str
if (exp.is_a?(String) && act.is_a?(String)) ||
(exp.is_a?(Regexp) && act.is_a?(Regexp))
exp_comment = " (#{exp.encoding})"
act_comment = " (#{act.encoding})"
elsif exp.is_a?(Float) && act.is_a?(Float)
exp_str = "%\#.#{Float::DIG+2}g" % exp
act_str = "%\#.#{Float::DIG+2}g" % act
elsif exp.is_a?(Time) && act.is_a?(Time)
if exp.subsec * 1000_000_000 == exp.nsec
exp_comment = " (#{exp.nsec}[ns])"
else
exp_comment = " (subsec=#{exp.subsec})"
end
if act.subsec * 1000_000_000 == act.nsec
act_comment = " (#{act.nsec}[ns])"
else
act_comment = " (subsec=#{act.subsec})"
end
elsif exp.class != act.class
# a subclass of Range, for example.
exp_comment = " (#{exp.class})"
act_comment = " (#{act.class})"
end
elsif !Encoding.compatible?(exp_str, act_str)
if exp.is_a?(String) && act.is_a?(String)
exp_str = exp.dump
act_str = act.dump
exp_comment = " (#{exp.encoding})"
act_comment = " (#{act.encoding})"
else
exp_str = exp_str.dump
act_str = act_str.dump
end
end
"<#{exp_str}>#{exp_comment} expected but was\n<#{act_str}>#{act_comment}"
}
assert(exp == act, msg)
end
# :call-seq:
# assert_not_nil( expression, failure_message = nil )
#
#Tests if +expression+ is not nil.
#
#An optional failure message may be provided as the final argument.
def assert_not_nil(exp, msg=nil)
msg = message(msg) { "<#{mu_pp(exp)}> expected to not be nil" }
assert(!exp.nil?, msg)
end
# :call-seq:
# assert_not_equal( expected, actual, failure_message = nil )
#
#Tests if +expected+ is not equal to +actual+.
#
#An optional failure message may be provided as the final argument.
def assert_not_equal(exp, act, msg=nil)
msg = message(msg) { "<#{mu_pp(exp)}> expected to be != to\n<#{mu_pp(act)}>" }
assert(exp != act, msg)
end
# :call-seq:
# assert_no_match( regexp, string, failure_message = nil )
#
#Tests if the given Regexp does not match a given String.
#
#An optional failure message may be provided as the final argument.
def assert_no_match(regexp, string, msg=nil)
assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
self._assertions -= 1
msg = message(msg) { "<#{mu_pp(regexp)}> expected to not match\n<#{mu_pp(string)}>" }
assert(regexp !~ string, msg)
end
# :call-seq:
# assert_not_same( expected, actual, failure_message = nil )
#
#Tests if +expected+ is not the same object as +actual+.
#This test uses Object#equal? to test equality.
#
#An optional failure message may be provided as the final argument.
#
# assert_not_same("x", "x") #Succeeds
def assert_not_same(expected, actual, message="")
msg = message(msg) { build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__) }
<?>
with id <?> expected to not be equal\\? to
<?>
with id <?>.
EOT
assert(!actual.equal?(expected), msg)
end
# :call-seq:
# assert_respond_to( object, method, failure_message = nil )
#
#Tests if the given Object responds to +method+.
#
#An optional failure message may be provided as the final argument.
#
# assert_respond_to("hello", :reverse) #Succeeds
# assert_respond_to("hello", :does_not_exist) #Fails
def assert_respond_to obj, (meth, priv), msg = nil
if priv
msg = message(msg) {
"Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}#{" privately" if priv}"
}
return assert obj.respond_to?(meth, priv), msg
end
#get rid of overcounting
super if !caller[0].rindex(MINI_DIR, 0) || !obj.respond_to?(meth)
end
# :call-seq:
# assert_send( +send_array+, failure_message = nil )
#
# Passes if the method send returns a true value.
#
# +send_array+ is composed of:
# * A receiver
# * A method
# * Arguments to the method
#
# Example:
# assert_send(["Hello world", :include?, "Hello"]) # -> pass
# assert_send(["Hello world", :include?, "Goodbye"]) # -> fail
def assert_send send_ary, m = nil
recv, msg, *args = send_ary
m = message(m) {
if args.empty?
argsstr = ""
else
(argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)')
end
"Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return true"
}
assert recv.__send__(msg, *args), m
end
# :call-seq:
# assert_not_send( +send_array+, failure_message = nil )
#
# Passes if the method send doesn't return a true value.
#
# +send_array+ is composed of:
# * A receiver
# * A method
# * Arguments to the method
#
# Example:
# assert_not_send([[1, 2], :member?, 1]) # -> fail
# assert_not_send([[1, 2], :member?, 4]) # -> pass
def assert_not_send send_ary, m = nil
recv, msg, *args = send_ary
m = message(m) {
if args.empty?
argsstr = ""
else
(argsstr = mu_pp(args)).sub!(/\A\[(.*)\]\z/m, '(\1)')
end
"Expected #{mu_pp(recv)}.#{msg}#{argsstr} to return false"
}
assert !recv.__send__(msg, *args), m
end
ms = instance_methods(true).map {|sym| sym.to_s }
ms.grep(/\Arefute_/) do |m|
mname = ('assert_not_' << m.to_s[/.*?_(.*)/, 1])
alias_method(mname, m) unless ms.include? mname
end
alias assert_include assert_includes
alias assert_not_include assert_not_includes
def assert_all?(obj, m = nil, &blk)
failed = []
obj.each do |*a, &b|
unless blk.call(*a, &b)
failed << (a.size > 1 ? a : a[0])
end
end
assert(failed.empty?, message(m) {failed.pretty_inspect})
end
def assert_not_all?(obj, m = nil, &blk)
failed = []
obj.each do |*a, &b|
if blk.call(*a, &b)
failed << a.size > 1 ? a : a[0]
end
end
assert(failed.empty?, message(m) {failed.pretty_inspect})
end
def build_message(head, template=nil, *arguments) #:nodoc:
template &&= template.chomp
template.gsub(/\G((?:[^\\]|\\.)*?)(\\)?\?/) { $1 + ($2 ? "?" : mu_pp(arguments.shift)) }
end
def message(msg = nil, *args, &default) # :nodoc:
if Proc === msg
super(nil, *args) do
[msg.call, (default.call if default)].compact.reject(&:empty?).join(".\n")
end
else
super
end
end
end
end
end

189
lib/test/unit/parallel.rb
View file

@ -1,189 +0,0 @@
require 'test/unit'
module Test
module Unit
class Worker < Runner # :nodoc:
class << self
undef autorun
end
alias orig_run_suite mini_run_suite
undef _run_suite
undef _run_suites
undef run
def increment_io(orig) # :nodoc:
*rest, io = 32.times.inject([orig.dup]){|ios, | ios << ios.last.dup }
rest.each(&:close)
io
end
def _run_suites(suites, type) # :nodoc:
suites.map do |suite|
_run_suite(suite, type)
end
end
def _run_suite(suite, type) # :nodoc:
@partial_report = []
orig_testout = MiniTest::Unit.output
i,o = IO.pipe
MiniTest::Unit.output = o
orig_stdin, orig_stdout = $stdin, $stdout
th = Thread.new do
begin
while buf = (self.verbose ? i.gets : i.read(5))
_report "p", buf
end
rescue IOError
rescue Errno::EPIPE
end
end
e, f, s = @errors, @failures, @skips
begin
result = orig_run_suite(suite, type)
rescue Interrupt
@need_exit = true
result = [nil,nil]
end
MiniTest::Unit.output = orig_testout
$stdin = orig_stdin
$stdout = orig_stdout
o.close
begin
th.join
rescue IOError
raise unless ["stream closed","closed stream"].include? $!.message
end
i.close
result << @partial_report
@partial_report = nil
result << [@errors-e,@failures-f,@skips-s]
result << ($: - @old_loadpath)
result << suite.name
begin
_report "done", Marshal.dump(result)
rescue Errno::EPIPE; end
return result
ensure
MiniTest::Unit.output = orig_stdout
$stdin = orig_stdin
$stdout = orig_stdout
o.close if o && !o.closed?
i.close if i && !i.closed?
end
def run(args = []) # :nodoc:
process_args args
@@stop_auto_run = true
@opts = @options.dup
@need_exit = false
@old_loadpath = []
begin
begin
@stdout = increment_io(STDOUT)
@stdin = increment_io(STDIN)
rescue
exit 2
end
exit 2 unless @stdout && @stdin
@stdout.sync = true
_report "ready!"
while buf = @stdin.gets
case buf.chomp
when /^loadpath (.+?)$/
@old_loadpath = $:.dup
$:.push(*Marshal.load($1.unpack("m")[0].force_encoding("ASCII-8BIT"))).uniq!
when /^run (.+?) (.+?)$/
_report "okay"
@options = @opts.dup
suites = MiniTest::Unit::TestCase.test_suites
begin
require $1
rescue LoadError
_report "after", Marshal.dump([$1, ProxyError.new($!)])
_report "ready"
next
end
_run_suites MiniTest::Unit::TestCase.test_suites-suites, $2.to_sym
if @need_exit
begin
_report "bye"
rescue Errno::EPIPE; end
exit
else
_report "ready"
end
when /^quit$/
begin
_report "bye"
rescue Errno::EPIPE; end
exit
end
end
rescue Errno::EPIPE
rescue Exception => e
begin
trace = e.backtrace
err = ["#{trace.shift}: #{e.message} (#{e.class})"] + trace.map{|t| t.prepend("\t") }
_report "bye", Marshal.dump(err.join("\n"))
rescue Errno::EPIPE;end
exit
ensure
@stdin.close if @stdin
@stdout.close if @stdout
end
end
def _report(res, *args) # :nodoc:
res = "#{res} #{args.pack("m0")}" unless args.empty?
@stdout.puts(res)
end
def puke(klass, meth, e) # :nodoc:
if e.is_a?(MiniTest::Skip)
new_e = MiniTest::Skip.new(e.message)
new_e.set_backtrace(e.backtrace)
e = new_e
end
@partial_report << [klass.name, meth, e.is_a?(MiniTest::Assertion) ? e : ProxyError.new(e)]
super
end
end
end
end
if $0 == __FILE__
module Test
module Unit
class TestCase < MiniTest::Unit::TestCase # :nodoc: all
undef on_parallel_worker?
def on_parallel_worker?
true
end
end
end
end
require 'rubygems'
module Gem # :nodoc:
end
class Gem::TestCase < MiniTest::Unit::TestCase # :nodoc:
@@project_dir = File.expand_path('../../../..', __FILE__)
end
Test::Unit::Worker.new.run(ARGV)
end

18
lib/test/unit/test-unit.gemspec
View file

@ -1,18 +0,0 @@
# -*- ruby -*-
Gem::Specification.new do |s|
s.name = "test-unit"
s.version = "#{RUBY_VERSION}.0"
s.homepage = "http://www.ruby-lang.org"
s.author = "Shota Fukumori"
s.email = "sorah@tubusu.net"
s.summary = "test/unit compatible API testing framework"
s.description =
"This library implements test/unit compatible API on minitest. " +
"The test/unit means that test/unit which was bundled with Ruby 1.8."
s.executables = ["testrb"]
# Ruby bundled test/unit is a compatibility layer for minitest,
# and it doesn't have support for minitest 5.
s.add_runtime_dependency "minitest", '< 5.0.0'
end

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

@ -1,34 +0,0 @@
require 'test/unit/assertions'
module Test
module Unit
# remove silly TestCase class
remove_const(:TestCase) if defined?(self::TestCase)
class TestCase < MiniTest::Unit::TestCase # :nodoc: all
include Assertions
def on_parallel_worker?
false
end
def run runner
@options = runner.options
super runner
end
def self.test_order
:sorted
end
def self.method_added(name)
return unless name.to_s.start_with?("test_")
@test_methods ||= {}
if @test_methods[name]
warn "test/unit warning: method #{ self }##{ name } is redefined"
end
@test_methods[name] = true
end
end
end
end