|
#\ruby\lib\ruby\1.8\test\unit\autorunner.rb
|
|
require 'test/unit'
|
|
require 'test/unit/ui/testrunnerutilities'
|
|
require 'optparse'
|
|
|
|
module Test
|
|
module Unit
|
|
class AutoRunner
|
|
def self.run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
|
|
r = new(force_standalone || standalone?, &block)
|
|
r.base = default_dir
|
|
r.process_args(argv)
|
|
r.run
|
|
end
|
|
|
|
def self.standalone?
|
|
return false unless("-e" == $0)
|
|
ObjectSpace.each_object(Class) do |klass|
|
|
return false if(klass < TestCase)
|
|
end
|
|
true
|
|
end
|
|
|
|
RUNNERS = {
|
|
:console => proc do |r|
|
|
require 'test/unit/ui/console/testrunner'
|
|
Test::Unit::UI::Console::TestRunner
|
|
end,
|
|
:gtk => proc do |r|
|
|
require 'test/unit/ui/gtk/testrunner'
|
|
Test::Unit::UI::GTK::TestRunner
|
|
end,
|
|
:gtk2 => proc do |r|
|
|
require 'test/unit/ui/gtk2/testrunner'
|
|
Test::Unit::UI::GTK2::TestRunner
|
|
end,
|
|
:fox => proc do |r|
|
|
require 'test/unit/ui/fox/testrunner'
|
|
Test::Unit::UI::Fox::TestRunner
|
|
end,
|
|
:tk => proc do |r|
|
|
require 'test/unit/ui/tk/testrunner'
|
|
Test::Unit::UI::Tk::TestRunner
|
|
end,
|
|
}
|
|
|
|
OUTPUT_LEVELS = [
|
|
[:silent, UI::SILENT],
|
|
[:progress, UI::PROGRESS_ONLY],
|
|
[:normal, UI::NORMAL],
|
|
[:verbose, UI::VERBOSE],
|
|
]
|
|
|
|
COLLECTORS = {
|
|
:objectspace => proc do |r|
|
|
require 'test/unit/collector/objectspace'
|
|
c = Collector::ObjectSpace.new
|
|
c.filter = r.filters
|
|
c.collect($0.sub(/\.rb\Z/, ''))
|
|
end,
|
|
:dir => proc do |r|
|
|
require 'test/unit/collector/dir'
|
|
c = Collector::Dir.new
|
|
c.filter = r.filters
|
|
c.pattern.concat(r.pattern) if(r.pattern)
|
|
c.exclude.concat(r.exclude) if(r.exclude)
|
|
c.base = r.base
|
|
$:.push(r.base) if r.base
|
|
c.collect(*(r.to_run.empty? ? ['.'] : r.to_run))
|
|
end,
|
|
}
|
|
|
|
attr_reader :suite
|
|
attr_accessor :output_level, :filters, :to_run, :pattern, :exclude, :base, :workdir
|
|
attr_accessor :output_io
|
|
attr_writer :runner, :collector
|
|
|
|
def initialize(standalone)
|
|
Unit.run = true
|
|
@standalone = standalone
|
|
@runner = RUNNERS[:console]
|
|
@collector = COLLECTORS[(standalone ? :dir : :objectspace)]
|
|
@filters = []
|
|
@to_run = []
|
|
@output_level = UI::NORMAL
|
|
@workdir = nil
|
|
@output_io = STDOUT
|
|
yield(self) if(block_given?)
|
|
end
|
|
|
|
def process_args(args = ARGV)
|
|
begin
|
|
options.order!(args) {|arg| @to_run << arg}
|
|
rescue OptionParser::ParseError => e
|
|
puts e
|
|
puts options
|
|
$! = nil
|
|
abort
|
|
else
|
|
@filters << proc{false} unless(@filters.empty?)
|
|
end
|
|
not @to_run.empty?
|
|
end
|
|
|
|
def options
|
|
@options ||= OptionParser.new do |o|
|
|
o.banner = "Test::Unit automatic runner."
|
|
o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
|
|
|
|
o.on
|
|
o.on('-r', '--runner=RUNNER', RUNNERS,
|
|
"Use the given RUNNER.",
|
|
"(" + keyword_display(RUNNERS) + ")") do |r|
|
|
@runner = r
|
|
end
|
|
|
|
if(@standalone)
|
|
o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
|
|
@base = b
|
|
end
|
|
|
|
o.on('-w', '--workdir=DIR', "Working directory to run tests.") do |w|
|
|
@workdir = w
|
|
end
|
|
|
|
o.on('-a', '--add=TORUN', Array,
|
|
"Add TORUN to the list of things to run;",
|
|
"can be a file or a directory.") do |a|
|
|
@to_run.concat(a)
|
|
end
|
|
|
|
@pattern = []
|
|
o.on('-p', '--pattern=PATTERN', Regexp,
|
|
"Match files to collect against PATTERN.") do |e|
|
|
@pattern << e
|
|
end
|
|
|
|
@exclude = []
|
|
o.on('-x', '--exclude=PATTERN', Regexp,
|
|
"Ignore files to collect against PATTERN.") do |e|
|
|
@exclude << e
|
|
end
|
|
end
|
|
|
|
o.on('-n', '--name=NAME', String,
|
|
"Runs tests matching NAME.",
|
|
"(patterns may be used).") do |n|
|
|
n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
|
|
case n
|
|
when Regexp
|
|
@filters << proc{|t| n =~ t.method_name ? true : nil}
|
|
else
|
|
@filters << proc{|t| n == t.method_name ? true : nil}
|
|
end
|
|
end
|
|
|
|
o.on('-o', '--output=[+]FILE', String,
|
|
"Write output to FILE.",
|
|
"Use '+' to append; FILE = STDOUT, STDERR or filename (default=STDOUT)") do |f|
|
|
case f
|
|
when nil, '', 'STDOUT'
|
|
@output_io = STDOUT
|
|
when 'STDERR'
|
|
@output_io = STDERR
|
|
else
|
|
if f =~ /^\+/
|
|
@output_io = File.new(f[1..f.length], 'a')
|
|
else
|
|
@output_io = File.new(f, 'w')
|
|
end
|
|
end
|
|
end
|
|
|
|
o.on('-t', '--testcase=TESTCASE', String,
|
|
"Runs tests in TestCases matching TESTCASE.",
|
|
"(patterns may be used).") do |n|
|
|
n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
|
|
case n
|
|
when Regexp
|
|
@filters << proc{|t| n =~ t.class.name ? true : nil}
|
|
else
|
|
@filters << proc{|t| n == t.class.name ? true : nil}
|
|
end
|
|
end
|
|
|
|
o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
|
|
"Appends directory list to $LOAD_PATH.") do |dirs|
|
|
$LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
|
|
end
|
|
|
|
o.on('-v', '--verbose=[LEVEL]', OUTPUT_LEVELS,
|
|
"Set the output level (default is verbose).",
|
|
"(" + keyword_display(OUTPUT_LEVELS) + ")") do |l|
|
|
@output_level = l || UI::VERBOSE
|
|
end
|
|
|
|
o.on('--',
|
|
"Stop processing options so that the",
|
|
"remaining options will be passed to the",
|
|
"test."){o.terminate}
|
|
|
|
o.on('-h', '--help', 'Display this help.'){puts o; exit}
|
|
|
|
o.on_tail
|
|
o.on_tail('Deprecated options:')
|
|
|
|
o.on_tail('--console', 'Console runner (use --runner).') do
|
|
warn("Deprecated option (--console).")
|
|
@runner = RUNNERS[:console]
|
|
end
|
|
|
|
o.on_tail('--gtk', 'GTK runner (use --runner).') do
|
|
warn("Deprecated option (--gtk).")
|
|
@runner = RUNNERS[:gtk]
|
|
end
|
|
|
|
o.on_tail('--fox', 'Fox runner (use --runner).') do
|
|
warn("Deprecated option (--fox).")
|
|
@runner = RUNNERS[:fox]
|
|
end
|
|
|
|
o.on_tail
|
|
end
|
|
end
|
|
|
|
def keyword_display(array)
|
|
list = array.collect {|e, *| e.to_s}
|
|
Array === array or list.sort!
|
|
list.collect {|e| e.sub(/^(.)([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')}.join(", ")
|
|
end
|
|
|
|
def run
|
|
@suite = @collector[self]
|
|
result = @runner[self] or return false
|
|
Dir.chdir(@workdir) if @workdir
|
|
result.run(@suite, @output_level, @output_io).passed?
|
|
end
|
|
end
|
|
end
|
|
end
|