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/unit: removed test/unit.

Browse source 
* lib/test/unit.rb: new compatibility layer using minitest.

* bin/testrb: use above.

* test/runner.rb: ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@19800 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2008-10-16 13:55:09 +00:00
parent 7485e91f76
commit 0ebf9b1763
25 changed files with 138 additions and 3597 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
ChangeLog
View file

@ -1,3 +1,13 @@
Thu Oct 16 22:52:54 2008 Tanaka Akira <akr@fsij.org>
* lib/test/unit: removed test/unit.
* lib/test/unit.rb: new compatibility layer using minitest.
* bin/testrb: use above.
* test/runner.rb: ditto.
Thu Oct 16 14:34:16 2008 Nobuyoshi Nakada <nobu@ruby-lang.org>
* common.mk, enc/depend (enc, trans): targets for sources.

4
bin/testrb
View file

@ -1,5 +1,3 @@
#!/usr/bin/env ruby
require 'test/unit'
(r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
abort r.options.banner + " tests..."
exit r.run
Test::Unit.setup_argv

396
lib/test/unit.rb
View file

@ -1,280 +1,134 @@
require 'test/unit/testcase'
require 'test/unit/autorunner'
# test/unit compatibility layer using minitest.
module Test # :nodoc:
#
# = Test::Unit - Ruby Unit Testing Framework
#
# == Introduction
#
# Unit testing is making waves all over the place, largely due to the
# fact that it is a core practice of XP. While XP is great, unit testing
# has been around for a long time and has always been a good idea. One
# of the keys to good unit testing, though, is not just writing tests,
# but having tests. What's the difference? Well, if you just _write_ a
# test and throw it away, you have no guarantee that something won't
# change later which breaks your code. If, on the other hand, you _have_
# tests (obviously you have to write them first), and run them as often
# as possible, you slowly build up a wall of things that cannot break
# without you immediately knowing about it. This is when unit testing
# hits its peak usefulness.
#
# Enter Test::Unit, a framework for unit testing in Ruby, helping you to
# design, debug and evaluate your code by making it easy to write and
# have tests for it.
#
#
# == Notes
#
# Test::Unit has grown out of and superceded Lapidary.
#
#
# == Feedback
#
# I like (and do my best to practice) XP, so I value early releases,
# user feedback, and clean, simple, expressive code. There is always
# room for improvement in everything I do, and Test::Unit is no
# exception. Please, let me know what you think of Test::Unit as it
# stands, and what you'd like to see expanded/changed/improved/etc. If
# you find a bug, let me know ASAP; one good way to let me know what the
# bug is is to submit a new test that catches it :-) Also, I'd love to
# hear about any successes you have with Test::Unit, and any
# documentation you might add will be greatly appreciated. My contact
# info is below.
#
#
# == Contact Information
#
# A lot of discussion happens about Ruby in general on the ruby-talk
# mailing list (http://www.ruby-lang.org/en/ml.html), and you can ask
# any questions you might have there. I monitor the list, as do many
# other helpful Rubyists, and you're sure to get a quick answer. Of
# course, you're also welcome to email me (Nathaniel Talbott) directly
# at mailto:testunit@talbott.ws, and I'll do my best to help you out.
#
#
# == Credits
#
# I'd like to thank...
#
# Matz, for a great language!
#
# Masaki Suketa, for his work on RubyUnit, which filled a vital need in
# the Ruby world for a very long time. I'm also grateful for his help in
# polishing Test::Unit and getting the RubyUnit compatibility layer
# right. His graciousness in allowing Test::Unit to supercede RubyUnit
# continues to be a challenge to me to be more willing to defer my own
# rights.
#
# Ken McKinlay, for his interest and work on unit testing, and for his
# willingness to dialog about it. He was also a great help in pointing
# out some of the holes in the RubyUnit compatibility layer.
#
# Dave Thomas, for the original idea that led to the extremely simple
# "require 'test/unit'", plus his code to improve it even more by
# allowing the selection of tests from the command-line. Also, without
# RDoc, the documentation for Test::Unit would stink a lot more than it
# does now.
#
# Everyone who's helped out with bug reports, feature ideas,
# encouragement to continue, etc. It's a real privilege to be a part of
# the Ruby community.
#
# The guys at RoleModel Software, for putting up with me repeating, "But
# this would be so much easier in Ruby!" whenever we're coding in Java.
#
# My Creator, for giving me life, and giving it more abundantly.
#
#
# == License
#
# Test::Unit is copyright (c) 2000-2003 Nathaniel Talbott. It is free
# software, and is distributed under the Ruby license. See the COPYING
# file in the standard Ruby distribution for details.
#
#
# == Warranty
#
# This software is provided "as is" and without any express or
# implied warranties, including, without limitation, the implied
# warranties of merchantibility and fitness for a particular
# purpose.
#
#
# == Author
#
# Nathaniel Talbott.
# Copyright (c) 2000-2003, Nathaniel Talbott
#
# ----
#
# = Usage
#
# The general idea behind unit testing is that you write a _test_
# _method_ that makes certain _assertions_ about your code, working
# against a _test_ _fixture_. A bunch of these _test_ _methods_ are
# bundled up into a _test_ _suite_ and can be run any time the
# developer wants. The results of a run are gathered in a _test_
# _result_ and displayed to the user through some UI. So, lets break
# this down and see how Test::Unit provides each of these necessary
# pieces.
#
#
# == Assertions
#
# These are the heart of the framework. Think of an assertion as a
# statement of expected outcome, i.e. "I assert that x should be equal
# to y". If, when the assertion is executed, it turns out to be
# correct, nothing happens, and life is good. If, on the other hand,
# your assertion turns out to be false, an error is propagated with
# pertinent information so that you can go back and make your
# assertion succeed, and, once again, life is good. For an explanation
# of the current assertions, see Test::Unit::Assertions.
#
#
# == Test Method & Test Fixture
#
# Obviously, these assertions have to be called within a context that
# knows about them and can do something meaningful with their
# pass/fail value. Also, it's handy to collect a bunch of related
# tests, each test represented by a method, into a common test class
# that knows how to run them. The tests will be in a separate class
# from the code they're testing for a couple of reasons. First of all,
# it allows your code to stay uncluttered with test code, making it
# easier to maintain. Second, it allows the tests to be stripped out
# for deployment, since they're really there for you, the developer,
# and your users don't need them. Third, and most importantly, it
# allows you to set up a common test fixture for your tests to run
# against.
#
# What's a test fixture? Well, tests do not live in a vacuum; rather,
# they're run against the code they are testing. Often, a collection
# of tests will run against a common set of data, also called a
# fixture. If they're all bundled into the same test class, they can
# all share the setting up and tearing down of that data, eliminating
# unnecessary duplication and making it much easier to add related
# tests.
#
# Test::Unit::TestCase wraps up a collection of test methods together
# and allows you to easily set up and tear down the same test fixture
# for each test. This is done by overriding #setup and/or #teardown,
# which will be called before and after each test method that is
# run. The TestCase also knows how to collect the results of your
# assertions into a Test::Unit::TestResult, which can then be reported
# back to you... but I'm getting ahead of myself. To write a test,
# follow these steps:
#
# * Make sure Test::Unit is in your library path.
# * require 'test/unit' in your test script.
# * Create a class that subclasses Test::Unit::TestCase.
# * Add a method that begins with "test" to your class.
# * Make assertions in your test method.
# * Optionally define #setup and/or #teardown to set up and/or tear
# down your common test fixture.
# * You can now run your test as you would any other Ruby
# script... try it and see!
#
# A really simple test might look like this (#setup and #teardown are
# commented out to indicate that they are completely optional):
#
# require 'test/unit'
#
# class TC_MyTest < Test::Unit::TestCase
# # def setup
# # end
#
# # def teardown
# # end
#
# def test_fail
# assert(false, 'Assertion was false.')
# end
# end
#
#
# == Test Runners
#
# So, now you have this great test class, but you still need a way to
# run it and view any failures that occur during the run. This is
# where Test::Unit::UI::Console::TestRunner (and others, such as
# Test::Unit::UI::GTK::TestRunner) comes into play. The console test
# runner is automatically invoked for you if you require 'test/unit'
# and simply run the file. To use another runner, or to manually
# invoke a runner, simply call its run class method and pass in an
# object that responds to the suite message with a
# Test::Unit::TestSuite. This can be as simple as passing in your
# TestCase class (which has a class suite method). It might look
# something like this:
#
# require 'test/unit/ui/console/testrunner'
# Test::Unit::UI::Console::TestRunner.run(TC_MyTest)
#
#
# == Test Suite
#
# As more and more unit tests accumulate for a given project, it
# becomes a real drag running them one at a time, and it also
# introduces the potential to overlook a failing test because you
# forget to run it. Suddenly it becomes very handy that the
# TestRunners can take any object that returns a Test::Unit::TestSuite
# in response to a suite method. The TestSuite can, in turn, contain
# other TestSuites or individual tests (typically created by a
# TestCase). In other words, you can easily wrap up a group of
# TestCases and TestSuites like this:
#
# require 'test/unit/testsuite'
# require 'tc_myfirsttests'
# require 'tc_moretestsbyme'
# require 'ts_anothersetoftests'
#
# class TS_MyTests
# def self.suite
# suite = Test::Unit::TestSuite.new
# suite << TC_MyFirstTests.suite
# suite << TC_MoreTestsByMe.suite
# suite << TS_AnotherSetOfTests.suite
# return suite
# end
# end
# Test::Unit::UI::Console::TestRunner.run(TS_MyTests)
#
# Now, this is a bit cumbersome, so Test::Unit does a little bit more
# for you, by wrapping these up automatically when you require
# 'test/unit'. What does this mean? It means you could write the above
# test case like this instead:
#
# require 'test/unit'
# require 'tc_myfirsttests'
# require 'tc_moretestsbyme'
# require 'ts_anothersetoftests'
#
# Test::Unit is smart enough to find all the test cases existing in
# the ObjectSpace and wrap them up into a suite for you. It then runs
# the dynamic suite using the console TestRunner.
#
#
# == Questions?
#
# I'd really like to get feedback from all levels of Ruby
# practitioners about typos, grammatical errors, unclear statements,
# missing points, etc., in this document (or any other).
#
require 'minitest/unit'
require 'pp'
module Test
module Unit
# If set to false Test::Unit will not automatically run at exit.
def self.run=(flag)
@run = flag
TEST_UNIT_IMPLEMENTATION = 'test/unit compatibility layer using minitest'
def self.setup_argv(original_argv=ARGV)
argv = []
files = nil
reject = []
original_argv = original_argv.dup
while arg = original_argv.shift
case arg
when '-v'
argv << '-v'
when '-n', '--name'
argv << arg
argv << original_argv.shift
when '-x'
reject << original_argv.shift
else
files ||= []
if File.directory? arg
files.concat Dir["#{arg}/**/test_*.rb"]
elsif File.file? arg
files << arg
else
raise ArgumentError, "file not found: #{arg}"
end
end
end
if files == nil
files = Dir["test/**/test_*.rb"]
end
reject_pat = Regexp.union(reject.map {|r| /#{r}/ })
files.reject! {|f| reject_pat =~ f }
files.each {|f|
d = File.dirname(File.expand_path(f))
unless $:.include? d
$: << d
end
begin
require f
rescue LoadError
puts $!
end
}
argv.concat files
ARGV.replace argv
end
# Automatically run tests at exit?
def self.run?
@run ||= false
module Assertions
include MiniTest::Assertions
def mu_pp(obj)
obj.pretty_inspect.chomp
end
def assert_raise(*args, &b)
assert_raises(*args, &b)
end
def assert_nothing_raised(*args)
if Module === args.last
msg = nil
else
msg = args.pop
end
begin
yield
rescue Exception => e
if ((args.empty? && !e.instance_of?(MiniTest::Assertion)) ||
args.any? {|a| a.instance_of?(Module) ? e.is_a?(a) : e.class == a })
msg = message(msg) { "Exception raised:\n<#{mu_pp(act)}>" }
assert(false, msg)
else
raise
end
end
nil
end
def assert_equal(exp, act, msg = nil)
msg = message(msg) { "Expected\n<#{mu_pp(exp)}> but\n<#{mu_pp(act)}>" }
assert(exp == act, msg)
end
def assert_not_nil(exp, msg=nil)
msg = message(msg) { "<#{mu_pp(exp)}> expected to not be nil" }
assert(!exp.nil?, msg)
end
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
def assert_no_match(regexp, string, msg=nil)
assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
msg = message(msg) { "<#{mu_pp(regexp)}> expected to not match\n<#{mu_pp(string)}>" }
assert(regexp !~ string, msg)
end
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
def build_message(head, template=nil, *arguments)
template &&= template.chomp
template.gsub(/\?/) { mu_pp(arguments.shift) }
end
end
class TestCase < MiniTest::Unit::TestCase
include Assertions
end
end
end
at_exit do
unless $! || Test::Unit.run?
exit Test::Unit::AutoRunner.run
end
end
MiniTest::Unit.autorun

14
lib/test/unit/assertionfailederror.rb
View file

@ -1,14 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
module Test
module Unit
# Thrown by Test::Unit::Assertions when an assertion fails.
class AssertionFailedError < StandardError
end
end
end

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

@ -1,622 +0,0 @@
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/assertionfailederror'
require 'test/unit/util/backtracefilter'
module Test # :nodoc:
module Unit # :nodoc:
##
# Test::Unit::Assertions contains the standard Test::Unit assertions.
# Assertions is included in Test::Unit::TestCase.
#
# To include it in your own code and use its functionality, you simply
# need to rescue Test::Unit::AssertionFailedError. Additionally you may
# override add_assertion to get notified whenever an assertion is made.
#
# Notes:
# * The message to each assertion, if given, will be propagated with the
# failure.
# * It is easy to add your own assertions based on assert_block().
#
# = Example Custom Assertion
#
# def deny(boolean, message = nil)
# message = build_message message, '<?> is not false or nil.', boolean
# assert_block message do
# not boolean
# end
# end
module Assertions
##
# The assertion upon which all other assertions are based. Passes if the
# block yields true.
#
# Example:
# assert_block "Couldn't do the thing" do
# do_the_thing
# end
public
def assert_block(message="assert_block failed.") # :yields:
_wrap_assertion do
if (! yield)
raise AssertionFailedError.new(message.to_s)
end
end
end
##
# Asserts that +boolean+ is not false or nil.
#
# Example:
# assert [1, 2].include?(5)
public
def assert(boolean, message=nil)
_wrap_assertion do
assert_block("assert should not be called with a block.") { !block_given? }
assert_block(build_message(message, "<?> is not true.", boolean)) { boolean }
end
end
##
# Passes if +expected+ == +actual.
#
# Note that the ordering of arguments is important, since a helpful
# error message is generated when this one fails that tells you the
# values of expected and actual.
#
# Example:
# assert_equal 'MY STRING', 'my string'.upcase
public
def assert_equal(expected, actual, message=nil)
full_message = build_message(message, <<EOT, expected, actual)
<?> expected but was
<?>.
EOT
assert_block(full_message) { expected == actual }
end
private
def _check_exception_class(args) # :nodoc:
args.partition do |klass|
next if klass.instance_of?(Module)
assert(Exception >= klass, "Should expect a class of exception, #{klass}")
true
end
end
private
def _expected_exception?(actual_exception, exceptions, modules) # :nodoc:
exceptions.include?(actual_exception.class) or
modules.any? {|mod| actual_exception.is_a?(mod)}
end
##
# Passes if the block raises one of the given exceptions.
#
# Example:
# assert_raise RuntimeError, LoadError do
# raise 'Boom!!!'
# end
public
def assert_raise(*args)
_wrap_assertion do
if Module === args.last
message = ""
else
message = args.pop
end
exceptions, modules = _check_exception_class(args)
expected = args.size == 1 ? args.first : args
actual_exception = nil
full_message = build_message(message, "<?> exception expected but none was thrown.", expected)
assert_block(full_message) do
begin
yield
rescue Exception => actual_exception
break
end
false
end
full_message = build_message(message, "<?> exception expected but was\n?", expected, actual_exception)
assert_block(full_message) {_expected_exception?(actual_exception, exceptions, modules)}
actual_exception
end
end
##
# Alias of assert_raise.
#
# Will be deprecated in 1.9, and removed in 2.0.
public
def assert_raises(*args, &block)
assert_raise(*args, &block)
end
##
# Passes if +object+ .instance_of? +klass+
#
# Example:
# assert_instance_of String, 'foo'
public
def assert_instance_of(klass, object, message="")
_wrap_assertion do
assert_equal(Class, klass.class, "assert_instance_of takes a Class as its first argument")
full_message = build_message(message, <<EOT, object, klass, object.class)
<?> expected to be an instance of
<?> but was
<?>.
EOT
assert_block(full_message){object.instance_of?(klass)}
end
end
##
# Passes if +object+ is nil.
#
# Example:
# assert_nil [1, 2].uniq!
public
def assert_nil(object, message="")
assert_equal(nil, object, message)
end
##
# Passes if +object+ .kind_of? +klass+
#
# Example:
# assert_kind_of Object, 'foo'
public
def assert_kind_of(klass, object, message="")
_wrap_assertion do
assert(klass.kind_of?(Module), "The first parameter to assert_kind_of should be a kind_of Module.")
full_message = build_message(message, "<?>\nexpected to be kind_of\\?\n<?> but was\n<?>.", object, klass, object.class)
assert_block(full_message){object.kind_of?(klass)}
end
end
##
# Passes if +object+ .respond_to? +method+
#
# Example:
# assert_respond_to 'bugbear', :slice
public
def assert_respond_to(object, method, message="")
_wrap_assertion do
full_message = build_message(nil, "<?>\ngiven as the method name argument to #assert_respond_to must be a Symbol or #respond_to\\?(:to_str).", method)
assert_block(full_message) do
method.kind_of?(Symbol) || method.respond_to?(:to_str)
end
full_message = build_message(message, <<EOT, object, object.class, method)
<?>
of type <?>
expected to respond_to\\?<?>.
EOT
assert_block(full_message) { object.respond_to?(method) }
end
end
##
# Passes if +string+ =~ +pattern+.
#
# Example:
# assert_match(/\d+/, 'five, 6, seven')
public
def assert_match(pattern, string, message="")
_wrap_assertion do
pattern = case(pattern)
when String
Regexp.new(Regexp.escape(pattern))
else
pattern
end
full_message = build_message(message, "<?> expected to be =~\n<?>.", string, pattern)
assert_block(full_message) { string =~ pattern }
end
end
##
# Passes if +actual+ .equal? +expected+ (i.e. they are the same
# instance).
#
# Example:
# o = Object.new
# assert_same o, o
public
def assert_same(expected, actual, message="")
full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
<?>
with id <?> expected to be equal\\? to
<?>
with id <?>.
EOT
assert_block(full_message) { actual.equal?(expected) }
end
##
# Compares the +object1+ with +object2+ using +operator+.
#
# Passes if object1.__send__(operator, object2) is true.
#
# Example:
# assert_operator 5, :>=, 4
public
def assert_operator(object1, operator, object2, message="")
_wrap_assertion do
full_message = build_message(nil, "<?>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
full_message = build_message(message, <<EOT, object1, AssertionMessage.literal(operator), object2)
<?> expected to be
?
<?>.
EOT
assert_block(full_message) { object1.__send__(operator, object2) }
end
end
##
# Passes if block does not raise an exception.
#
# Example:
# assert_nothing_raised do
# [1, 2].uniq
# end
public
def assert_nothing_raised(*args)
_wrap_assertion do
if Module === args.last
message = ""
else
message = args.pop
end
exceptions, modules = _check_exception_class(args)
begin
yield
rescue Exception => e
if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
_expected_exception?(e, exceptions, modules))
assert_block(build_message(message, "Exception raised:\n?", e)){false}
else
raise
end
end
nil
end
end
##
# Flunk always fails.
#
# Example:
# flunk 'Not done testing yet.'
public
def flunk(message="Flunked")
assert_block(build_message(message)){false}
end
##
# Passes if ! +actual+ .equal? +expected+
#
# Example:
# assert_not_same Object.new, Object.new
public
def assert_not_same(expected, actual, message="")
full_message = build_message(message, <<EOT, expected, expected.__id__, actual, actual.__id__)
<?>
with id <?> expected to not be equal\\? to
<?>
with id <?>.
EOT
assert_block(full_message) { !actual.equal?(expected) }
end
##
# Passes if +expected+ != +actual+
#
# Example:
# assert_not_equal 'some string', 5
public
def assert_not_equal(expected, actual, message="")
full_message = build_message(message, "<?> expected to be != to\n<?>.", expected, actual)
assert_block(full_message) { expected != actual }
end
##
# Passes if ! +object+ .nil?
#
# Example:
# assert_not_nil '1 two 3'.sub!(/two/, '2')
public
def assert_not_nil(object, message="")
full_message = build_message(message, "<?> expected to not be nil.", object)
assert_block(full_message){!object.nil?}
end
##
# Passes if +regexp+ !~ +string+
#
# Example:
# assert_no_match(/two/, 'one 2 three')
public
def assert_no_match(regexp, string, message="")
_wrap_assertion do
assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
full_message = build_message(message, "<?> expected to not match\n<?>.", regexp, string)
assert_block(full_message) { regexp !~ string }
end
end
UncaughtThrow = {
ArgumentError => /^uncaught throw (.+)$/,
} #`
##
# Passes if the block throws +expected_object+
#
# Example:
# assert_throws :done do
# throw :done
# end
public
def assert_throws(expected_object, message="", &proc)
_wrap_assertion do
assert_block("Should have passed a block to assert_throws."){block_given?}
caught = true
begin
catch(expected_object) do
proc.call
caught = false
end
full_message = build_message(message, "<?> should have been thrown.", expected_object)
assert_block(full_message){caught}
rescue ArgumentError => error
if UncaughtThrow[error.class] !~ error.message
raise error
end
full_message = build_message(message, "<?> expected to be thrown but\n<#$1> was thrown.", expected_object)
flunk(full_message)
end
end
end
##
# Passes if block does not throw anything.
#
# Example:
# assert_nothing_thrown do
# [1, 2].uniq
# end
public
def assert_nothing_thrown(message="", &proc)
_wrap_assertion do
assert(block_given?, "Should have passed a block to assert_nothing_thrown")
begin
proc.call
rescue ArgumentError => error
if UncaughtThrow[error.class] !~ error.message
raise error
end
full_message = build_message(message, "<#$1> was thrown when nothing was expected")
flunk(full_message)
end
assert(true, "Expected nothing to be thrown")
end
end
##
# Passes if +expected_float+ and +actual_float+ are equal
# within +delta+ tolerance.
#
# Example:
# assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
public
def assert_in_delta(expected_float, actual_float, delta, message="")
_wrap_assertion do
{expected_float => "first float", actual_float => "second float", delta => "delta"}.each do |float, name|
assert_respond_to(float, :to_f, "The arguments must respond to to_f; the #{name} did not")
end
assert_operator(delta, :>=, 0.0, "The delta should not be negative")
full_message = build_message(message, <<EOT, expected_float, actual_float, delta)
<?> and
<?> expected to be within
<?> of each other.
EOT
assert_block(full_message) { (expected_float.to_f - actual_float.to_f).abs <= delta.to_f }
end
end
##
# 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 [[1, 2], :include?, 4]
public
def assert_send(send_array, message="")
_wrap_assertion do
assert_instance_of(Array, send_array, "assert_send requires an array of send information")
assert(send_array.size >= 2, "assert_send requires at least a receiver and a message name")
full_message = build_message(message, <<EOT, send_array[0], AssertionMessage.literal(send_array[1].to_s), send_array[2..-1])
<?> expected to respond to
<?(?)> with a true value.
EOT
assert_block(full_message) { send_array[0].__send__(send_array[1], *send_array[2..-1]) }
end
end
##
# Builds a failure message. +head+ is added before the +template+ and
# +arguments+ replaces the '?'s positionally in the template.
public
def build_message(head, template=nil, *arguments) # :nodoc:
template &&= template.chomp
return AssertionMessage.new(head, template, arguments)
end
private
def _wrap_assertion # :nodoc:
@_assertion_wrapped ||= false
unless (@_assertion_wrapped)
@_assertion_wrapped = true
begin
add_assertion
return yield
ensure
@_assertion_wrapped = false
end
else
return yield
end
end
##
# Called whenever an assertion is made. Define this in classes that
# include Test::Unit::Assertions to record assertion counts.
private
def add_assertion
end
##
# Select whether or not to use the pretty-printer. If this option is set
# to false before any assertions are made, pp.rb will not be required.
public
def self.use_pp=(value)
AssertionMessage.use_pp = value
end
# :stopdoc:
class AssertionMessage
@use_pp = true
class << self
attr_accessor :use_pp
end
class Literal
def initialize(value)
@value = value
end
def inspect
@value.to_s
end
end
class Template
def self.create(string)
parts = (string ? string.scan(/(?=[^\\])\?|(?:\\\?|[^\?])+/m) : [])
self.new(parts)
end
attr_reader :count
def initialize(parts)
@parts = parts
@count = parts.find_all{|e| e == '?'}.size
end
def result(parameters)
raise "The number of parameters does not match the number of substitutions." if(parameters.size != count)
params = parameters.dup
@parts.collect{|e| e == '?' ? params.shift : e.gsub(/\\\?/m, '?')}.join('')
end
end
def self.literal(value)
Literal.new(value)
end
include Util::BacktraceFilter
def initialize(head, template_string, parameters)
@head = head
@template_string = template_string
@parameters = parameters
end
def convert(object)
case object
when Exception
<<EOM.chop
Class: <#{convert(object.class)}>
Message: <#{convert(object.message)}>
---Backtrace---
#{filter_backtrace(object.backtrace).join("\n")}
---------------
EOM
else
if(self.class.use_pp)
begin
require 'pp'
rescue LoadError
self.class.use_pp = false
return object.inspect
end unless(defined?(PP))
PP.pp(object, '').chomp
else
object.inspect
end
end
end
def template
@template ||= Template.create(@template_string)
end
def add_period(string)
(string =~ /\.\Z/ ? string : string + '.')
end
def to_s
message_parts = []
if (@head)
head = @head.to_s
unless(head.empty?)
message_parts << add_period(head)
end
end
tail = template.result(@parameters.collect{|e| convert(e)})
message_parts << tail unless(tail.empty?)
message_parts.join("\n")
end
end
# :startdoc:
end
end
end

217
lib/test/unit/autorunner.rb
View file

@ -1,217 +0,0 @@
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)
TestCase::DECENDANT_CLASSES.empty?
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_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 = false
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('-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).passed?
end
end
end
end

43
lib/test/unit/collector.rb
View file

@ -1,43 +0,0 @@
module Test
module Unit
module Collector
def initialize
@filters = []
end
def filter=(filters)
@filters = case(filters)
when Proc
[filters]
when Array
filters
end
end
def add_suite(destination, suite)
to_delete = suite.tests.find_all{|t| !include?(t)}
to_delete.each{|t| suite.delete(t)}
destination << suite unless(suite.size == 0)
end
def include?(test)
return true if(@filters.empty?)
@filters.each do |filter|
result = filter[test]
if(result.nil?)
next
elsif(!result)
return false
else
return true
end
end
true
end
def sort(suites)
suites.sort_by{|s| s.name}
end
end
end
end

113
lib/test/unit/collector/dir.rb
View file

@ -1,113 +0,0 @@
require 'test/unit/testsuite'
require 'test/unit/collector'
module Test
module Unit
module Collector
class Dir
include Collector
attr_reader :pattern, :exclude
attr_accessor :base
def initialize(dir=::Dir, file=::File, object_space=nil, req=nil)
super()
@dir = dir
@file = file
@object_space = object_space
@req = req
@pattern = [/\btest_.*\.rb\Z/m]
@exclude = []
end
def collect(*from)
basedir = @base
$:.push(basedir) if basedir
if(from.empty?)
recursive_collect('.', find_test_cases)
elsif(from.size == 1)
recursive_collect(from.first, find_test_cases)
else
suites = []
from.each do |f|
suite = recursive_collect(f, find_test_cases)
suites << suite unless(suite.tests.empty?)
end
suite = TestSuite.new("[#{from.join(', ')}]")
sort(suites).each{|s| suite << s}
suite
end
ensure
$:.delete_at($:.rindex(basedir)) if basedir
end
def find_test_cases(ignore=[])
cases = []
if @object_space
@object_space.each_object(Class) do |c|
cases << c if(c < TestCase && !ignore.include?(c))
end
else
TestCase::DECENDANT_CLASSES.each do |c|
cases << c if !ignore.include?(c)
end
end
ignore.concat(cases)
cases
end
def recursive_collect(name, already_gathered)
sub_suites = []
path = realdir(name)
if @file.directory?(path)
dir_name = name unless name == '.'
@dir.entries(path).each do |e|
next if(e == '.' || e == '..')
e_name = dir_name ? @file.join(dir_name, e) : e
if @file.directory?(realdir(e_name))
next if /\A(?:CVS|\.svn)\z/ =~ e
sub_suite = recursive_collect(e_name, already_gathered)
sub_suites << sub_suite unless(sub_suite.empty?)
else
next if /~\z/ =~ e_name or /\A\.\#/ =~ e
if @pattern and !@pattern.empty?
next unless @pattern.any? {|pat| pat =~ e_name}
end
if @exclude and !@exclude.empty?
next if @exclude.any? {|pat| pat =~ e_name}
end
collect_file(e_name, sub_suites, already_gathered)
end
end
else
collect_file(name, sub_suites, already_gathered)
end
suite = TestSuite.new(@file.basename(name))
sort(sub_suites).each{|s| suite << s}
suite
end
def collect_file(name, suites, already_gathered)
dir = @file.dirname(@file.expand_path(name, @base))
$:.unshift(dir)
if(@req)
@req.require(name)
else
require(name)
end
find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
ensure
$:.delete_at($:.index(dir)) if dir
end
def realdir(path)
if @base
@file.join(@base, path)
else
path
end
end
end
end
end
end

40
lib/test/unit/collector/objectspace.rb
View file

@ -1,40 +0,0 @@
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/collector'
module Test
module Unit
module Collector
class ObjectSpace
include Test::Unit::Collector
NAME = 'collected from the subclasses of TestCase'
def initialize(source=nil)
super()
@source = source
end
def collect(name=NAME)
suite = TestSuite.new(name)
sub_suites = []
if @source
@source.each_object(Class) do |klass|
if(Test::Unit::TestCase > klass)
add_suite(sub_suites, klass.suite)
end
end
else
TestCase::DECENDANT_CLASSES.each do |klass|
add_suite(sub_suites, klass.suite)
end
end
sort(sub_suites).each{|s| suite << s}
suite
end
end
end
end
end

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

@ -1,56 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/util/backtracefilter'
module Test
module Unit
# Encapsulates an error in a test. Created by
# Test::Unit::TestCase when it rescues an exception thrown
# during the processing of a test.
class Error
include Util::BacktraceFilter
attr_reader(:test_name, :exception)
SINGLE_CHARACTER = 'E'
# Creates a new Error with the given test_name and
# exception.
def initialize(test_name, exception)
@test_name = test_name
@exception = exception
end
# Returns a single character representation of an error.
def single_character_display
SINGLE_CHARACTER
end
# Returns the message associated with the error.
def message
"#{@exception.class.name}: #{@exception.message}"
end
# Returns a brief version of the error description.
def short_display
"#@test_name: #{message.split("\n")[0]}"
end
# Returns a verbose version of the error description.
def long_display
backtrace = filter_backtrace(@exception.backtrace).join("\n ")
"Error:\n#@test_name:\n#{message}\n #{backtrace}"
end
# Overridden to return long_display.
def to_s
long_display
end
end
end
end

51
lib/test/unit/failure.rb
View file

@ -1,51 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
module Test
module Unit
# Encapsulates a test failure. Created by Test::Unit::TestCase
# when an assertion fails.
class Failure
attr_reader :test_name, :location, :message
SINGLE_CHARACTER = 'F'
# Creates a new Failure with the given location and
# message.
def initialize(test_name, location, message)
@test_name = test_name
@location = location
@message = message
end
# Returns a single character representation of a failure.
def single_character_display
SINGLE_CHARACTER
end
# Returns a brief version of the error description.
def short_display
"#@test_name: #{@message.split("\n")[0]}"
end
# Returns a verbose version of the error description.
def long_display
location_display = if(location.size == 1)
location[0].sub(/\A(.+:\d+).*/, ' [\\1]')
else
"\n [#{location.join("\n ")}]"
end
"Failure:\n#@test_name#{location_display}:\n#@message"
end
# Overridden to return long_display.
def to_s
long_display
end
end
end
end

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

@ -1,163 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/assertions'
require 'test/unit/failure'
require 'test/unit/error'
require 'test/unit/testsuite'
require 'test/unit/assertionfailederror'
require 'test/unit/util/backtracefilter'
module Test
module Unit
# Ties everything together. If you subclass and add your own
# test methods, it takes care of making them into tests and
# wrapping those tests into a suite. It also does the
# nitty-gritty of actually running an individual test and
# collecting its results into a Test::Unit::TestResult object.
class TestCase
include Assertions
include Util::BacktraceFilter
attr_reader :method_name
STARTED = name + "::STARTED"
FINISHED = name + "::FINISHED"
##
# These exceptions are not caught by #run.
PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt,
SystemExit]
DECENDANT_CLASSES = []
def self.inherited(decendant)
DECENDANT_CLASSES << decendant
end
# Creates a new instance of the fixture for running the
# test represented by test_method_name.
def initialize(test_method_name)
unless(respond_to?(test_method_name) && method(test_method_name).arity == 0)
throw :invalid_test
end
@method_name = test_method_name
@test_passed = true
end
# Rolls up all of the test* methods in the fixture into
# one suite, creating a new instance of the fixture for
# each method.
def self.suite
method_names = public_instance_methods(true).map { |m| m.to_s }
tests = method_names.delete_if {|method_name| method_name !~ /^test./}
suite = TestSuite.new(name)
tests.sort.each do
|test|
catch(:invalid_test) do
suite << new(test)
end
end
if (suite.empty?)
catch(:invalid_test) do
suite << new(:default_test)
end
end
return suite
end
# Runs the individual test method represented by this
# instance of the fixture, collecting statistics, failures
# and errors in result.
def run(result)
yield(STARTED, name)
@_result = result
begin
setup
__send__(@method_name)
rescue AssertionFailedError => e
add_failure(e.message, e.backtrace)
rescue Exception
raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
add_error($!)
ensure
begin
teardown
rescue AssertionFailedError => e
add_failure(e.message, e.backtrace)
rescue Exception
raise if PASSTHROUGH_EXCEPTIONS.include? $!.class
add_error($!)
end
end
result.add_run
yield(FINISHED, name)
end
# Called before every test method runs. Can be used
# to set up fixture information.
def setup
end
# Called after every test method runs. Can be used to tear
# down fixture information.
def teardown
end
def default_test
flunk("No tests were specified")
end
# Returns whether this individual test passed or
# not. Primarily for use in teardown so that artifacts
# can be left behind if the test fails.
def passed?
return @test_passed
end
private :passed?
def size # :nodoc:
1
end
def add_assertion # :nodoc:
@_result.add_assertion
end
private :add_assertion
def add_failure(message, all_locations=caller()) # :nodoc:
@test_passed = false
@_result.add_failure(Failure.new(name, filter_backtrace(all_locations), message))
end
private :add_failure
def add_error(exception) # :nodoc:
@test_passed = false
@_result.add_error(Error.new(name, exception))
end
private :add_error
# Returns a human-readable name for the specific test that
# this instance of TestCase represents.
def name
"#{@method_name}(#{self.class.name})"
end
# Overridden to return #name.
def to_s
name
end
# It's handy to be able to compare TestCase instances.
def ==(other)
return false unless(other.kind_of?(self.class))
return false unless(@method_name == other.method_name)
self.class == other.class
end
end
end
end

81
lib/test/unit/testresult.rb
View file

@ -1,81 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/util/observable'
module Test
module Unit
# Collects Test::Unit::Failure and Test::Unit::Error so that
# they can be displayed to the user. To this end, observers
# can be added to it, allowing the dynamic updating of, say, a
# UI.
class TestResult
include Util::Observable
CHANGED = "CHANGED"
FAULT = "FAULT"
attr_reader(:run_count, :assertion_count)
# Constructs a new, empty TestResult.
def initialize
@run_count, @assertion_count = 0, 0
@failures, @errors = Array.new, Array.new
end
# Records a test run.
def add_run
@run_count += 1
notify_listeners(CHANGED, self)
end
# Records a Test::Unit::Failure.
def add_failure(failure)
@failures << failure
notify_listeners(FAULT, failure)
notify_listeners(CHANGED, self)
end
# Records a Test::Unit::Error.
def add_error(error)
@errors << error
notify_listeners(FAULT, error)
notify_listeners(CHANGED, self)
end
# Records an individual assertion.
def add_assertion
@assertion_count += 1
notify_listeners(CHANGED, self)
end
# Returns a string contain the recorded runs, assertions,
# failures and errors in this TestResult.
def to_s
"#{run_count} tests, #{assertion_count} assertions, #{failure_count} failures, #{error_count} errors"
end
# Returns whether or not this TestResult represents
# successful completion.
def passed?
return @failures.empty? && @errors.empty?
end
# Returns the number of failures this TestResult has
# recorded.
def failure_count
return @failures.size
end
# Returns the number of errors this TestResult has
# recorded.
def error_count
return @errors.size
end
end
end
end

76
lib/test/unit/testsuite.rb
View file

@ -1,76 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
module Test
module Unit
# A collection of tests which can be #run.
#
# Note: It is easy to confuse a TestSuite instance with
# something that has a static suite method; I know because _I_
# have trouble keeping them straight. Think of something that
# has a suite method as simply providing a way to get a
# meaningful TestSuite instance.
class TestSuite
attr_reader :name, :tests
STARTED = name + "::STARTED"
FINISHED = name + "::FINISHED"
# Creates a new TestSuite with the given name.
def initialize(name="Unnamed TestSuite")
@name = name
@tests = []
end
# Runs the tests and/or suites contained in this
# TestSuite.
def run(result, &progress_block)
yield(STARTED, name)
@tests.each do |test|
test.run(result, &progress_block)
end
yield(FINISHED, name)
end
# Adds the test to the suite.
def <<(test)
@tests << test
self
end
def delete(test)
@tests.delete(test)
end
# Retuns the rolled up number of tests in this suite;
# i.e. if the suite contains other suites, it counts the
# tests within those suites, not the suites themselves.
def size
total_size = 0
@tests.each { |test| total_size += test.size }
total_size
end
def empty?
tests.empty?
end
# Overridden to return the name given the suite at
# creation.
def to_s
@name
end
# It's handy to be able to compare TestSuite instances.
def ==(other)
return false unless(other.kind_of?(self.class))
return false unless(@name == other.name)
@tests == other.tests
end
end
end
end

130
lib/test/unit/ui/console/testrunner.rb
View file

@ -1,130 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/ui/testrunnermediator'
require 'test/unit/ui/testrunnerutilities'
module Test
module Unit
module UI
module Console # :nodoc:
# Runs a Test::Unit::TestSuite on the console.
class TestRunner
extend TestRunnerUtilities
# Creates a new TestRunner for running the passed
# suite. If quiet_mode is true, the output while
# running is limited to progress dots, errors and
# failures, and the final result. io specifies
# where runner output should go to; defaults to
# STDOUT.
def initialize(suite, output_level=NORMAL, io=STDOUT)
if (suite.respond_to?(:suite))
@suite = suite.suite
else
@suite = suite
end
@output_level = output_level
@io = io
@already_outputted = false
@faults = []
end
# Begins the test run.
def start
setup_mediator
attach_to_mediator
return start_mediator
end
private
def setup_mediator # :nodoc:
@mediator = create_mediator(@suite)
suite_name = @suite.to_s
if ( @suite.kind_of?(Module) )
suite_name = @suite.name
end
output("Loaded suite #{suite_name}")
end
def create_mediator(suite) # :nodoc:
return TestRunnerMediator.new(suite)
end
def attach_to_mediator # :nodoc:
@mediator.add_listener(TestResult::FAULT, &method(:add_fault))
@mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
@mediator.add_listener(TestCase::STARTED, &method(:test_started))
@mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
end
def start_mediator # :nodoc:
return @mediator.run_suite
end
def add_fault(fault) # :nodoc:
@faults << fault
output_single(fault.single_character_display, PROGRESS_ONLY)
@already_outputted = true
end
def started(result)
@result = result
output("Started")
end
def finished(elapsed_time)
nl
output("Finished in #{elapsed_time} seconds.")
@faults.each_with_index do |fault, index|
nl
output("%3d) %s" % [index + 1, fault.long_display])
end
nl
output(@result)
end
def test_started(name)
$program_name = $0
alias $0 $program_name
$PROGRAM_NAME += "\0#{name}"
output_single(name + ": ", VERBOSE)
end
def test_finished(name)
output_single(".", PROGRESS_ONLY) unless (@already_outputted)
nl(VERBOSE)
@already_outputted = false
end
def nl(level=NORMAL)
output("", level)
end
def output(something, level=NORMAL)
@io.puts(something) if (output?(level))
@io.flush
end
def output_single(something, level=NORMAL)
@io.write(something) if (output?(level))
@io.flush
end
def output?(level)
level <= @output_level
end
end
end
end
end
end
if __FILE__ == $0
Test::Unit::UI::Console::TestRunner.start_command_line_test
end

268
lib/test/unit/ui/fox/testrunner.rb
View file

@ -1,268 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'fox'
require 'test/unit/ui/testrunnermediator'
require 'test/unit/ui/testrunnerutilities'
include Fox
module Test
module Unit
module UI
module Fox # :nodoc:
# Runs a Test::Unit::TestSuite in a Fox UI. Obviously,
# this one requires you to have Fox
# (http://www.fox-toolkit.org/fox.html) and the Ruby
# Fox extension (http://fxruby.sourceforge.net/)
# installed.
class TestRunner
extend TestRunnerUtilities
RED_STYLE = FXRGBA(0xFF,0,0,0xFF) #0xFF000000
GREEN_STYLE = FXRGBA(0,0xFF,0,0xFF) #0x00FF0000
# Creates a new TestRunner for running the passed
# suite.
def initialize(suite, output_level = NORMAL)
if (suite.respond_to?(:suite))
@suite = suite.suite
else
@suite = suite
end
@result = nil
@red = false
end
# Begins the test run.
def start
setup_ui
setup_mediator
attach_to_mediator
start_ui
@result
end
def setup_mediator # :nodoc:
@mediator = TestRunnerMediator.new(@suite)
suite_name = @suite.to_s
if ( @suite.kind_of?(Module) )
suite_name = @suite.name
end
@suite_name_entry.text = suite_name
end
def attach_to_mediator # :nodoc:
@mediator.add_listener(TestRunnerMediator::RESET, &method(:reset_ui))
@mediator.add_listener(TestResult::FAULT, &method(:add_fault))
@mediator.add_listener(TestResult::CHANGED, &method(:result_changed))
@mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@mediator.add_listener(TestCase::STARTED, &method(:test_started))
@mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
end
def start_ui # :nodoc:
@application.create
@window.show(PLACEMENT_SCREEN)
@application.addTimeout(1) do
@mediator.run_suite
end
@application.run
end
def stop # :nodoc:
@application.exit(0)
end
def reset_ui(count) # :nodoc:
@test_progress_bar.barColor = GREEN_STYLE
@test_progress_bar.total = count
@test_progress_bar.progress = 0
@red = false
@test_count_label.text = "0"
@assertion_count_label.text = "0"
@failure_count_label.text = "0"
@error_count_label.text = "0"
@fault_list.clearItems
end
def add_fault(fault) # :nodoc:
if ( ! @red )
@test_progress_bar.barColor = RED_STYLE
@red = true
end
item = FaultListItem.new(fault)
@fault_list.appendItem(item)
end
def show_fault(fault) # :nodoc:
raw_show_fault(fault.long_display)
end
def raw_show_fault(string) # :nodoc:
@detail_text.setText(string)
end
def clear_fault # :nodoc:
raw_show_fault("")
end
def result_changed(result) # :nodoc:
@test_progress_bar.progress = result.run_count
@test_count_label.text = result.run_count.to_s
@assertion_count_label.text = result.assertion_count.to_s
@failure_count_label.text = result.failure_count.to_s
@error_count_label.text = result.error_count.to_s
# repaint now!
@info_panel.repaint
@application.flush
end
def started(result) # :nodoc:
@result = result
output_status("Started...")
end
def test_started(test_name)
output_status("Running #{test_name}...")
end
def finished(elapsed_time)
output_status("Finished in #{elapsed_time} seconds")
end
def output_status(string)
@status_entry.text = string
@status_entry.repaint
end
def setup_ui # :nodoc:
@application = create_application
create_tooltip(@application)
@window = create_window(@application)
@status_entry = create_entry(@window)
main_panel = create_main_panel(@window)
suite_panel = create_suite_panel(main_panel)
create_label(suite_panel, "Suite:")
@suite_name_entry = create_entry(suite_panel)
create_button(suite_panel, "&Run\tRun the current suite", proc { @mediator.run_suite })
@test_progress_bar = create_progress_bar(main_panel)
@info_panel = create_info_panel(main_panel)
create_label(@info_panel, "Tests:")
@test_count_label = create_label(@info_panel, "0")
create_label(@info_panel, "Assertions:")
@assertion_count_label = create_label(@info_panel, "0")
create_label(@info_panel, "Failures:")
@failure_count_label = create_label(@info_panel, "0")
create_label(@info_panel, "Errors:")
@error_count_label = create_label(@info_panel, "0")
list_panel = create_list_panel(main_panel)
@fault_list = create_fault_list(list_panel)
detail_panel = create_detail_panel(main_panel)
@detail_text = create_text(detail_panel)
end
def create_application # :nodoc:
app = FXApp.new("TestRunner", "Test::Unit")
app.init([])
app
end
def create_window(app)
FXMainWindow.new(app, "Test::Unit TestRunner", nil, nil, DECOR_ALL, 0, 0, 450)
end
def create_tooltip(app)
FXTooltip.new(app)
end
def create_main_panel(parent) # :nodoc:
panel = FXVerticalFrame.new(parent, LAYOUT_FILL_X | LAYOUT_FILL_Y)
panel.vSpacing = 10
panel
end
def create_suite_panel(parent) # :nodoc:
FXHorizontalFrame.new(parent, LAYOUT_SIDE_LEFT | LAYOUT_FILL_X)
end
def create_button(parent, text, action) # :nodoc:
FXButton.new(parent, text).connect(SEL_COMMAND, &action)
end
def create_progress_bar(parent) # :nodoc:
FXProgressBar.new(parent, nil, 0, PROGRESSBAR_NORMAL | LAYOUT_FILL_X)
end
def create_info_panel(parent) # :nodoc:
FXMatrix.new(parent, 1, MATRIX_BY_ROWS | LAYOUT_FILL_X)
end
def create_label(parent, text)
FXLabel.new(parent, text, nil, JUSTIFY_CENTER_X | LAYOUT_FILL_COLUMN)
end
def create_list_panel(parent) # :nodoc:
FXHorizontalFrame.new(parent, LAYOUT_FILL_X | FRAME_SUNKEN | FRAME_THICK)
end
def create_fault_list(parent) # :nodoc:
list = FXList.new(parent, 10, nil, 0, LIST_SINGLESELECT | LAYOUT_FILL_X) #, 0, 0, 0, 150)
list.connect(SEL_COMMAND) do |sender, sel, ptr|
if sender.retrieveItem(sender.currentItem).selected?
show_fault(sender.retrieveItem(sender.currentItem).fault)
else
clear_fault
end
end
list
end
def create_detail_panel(parent) # :nodoc:
FXHorizontalFrame.new(parent, LAYOUT_FILL_X | LAYOUT_FILL_Y | FRAME_SUNKEN | FRAME_THICK)
end
def create_text(parent) # :nodoc:
FXText.new(parent, nil, 0, TEXT_READONLY | LAYOUT_FILL_X | LAYOUT_FILL_Y)
end
def create_entry(parent) # :nodoc:
entry = FXTextField.new(parent, 30, nil, 0, TEXTFIELD_NORMAL | LAYOUT_SIDE_BOTTOM | LAYOUT_FILL_X)
entry.disable
entry
end
end
class FaultListItem < FXListItem # :nodoc: all
attr_reader(:fault)
def initialize(fault)
super(fault.short_display)
@fault = fault
end
end
end
end
end
end
if __FILE__ == $0
Test::Unit::UI::Fox::TestRunner.start_command_line_test
end

416
lib/test/unit/ui/gtk/testrunner.rb
View file

@ -1,416 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'gtk'
require 'test/unit/ui/testrunnermediator'
require 'test/unit/ui/testrunnerutilities'
module Test
module Unit
module UI
module GTK # :nodoc:
# Runs a Test::Unit::TestSuite in a Gtk UI. Obviously,
# this one requires you to have Gtk
# (http://www.gtk.org/) and the Ruby Gtk extension
# (http://ruby-gnome.sourceforge.net/) installed.
class TestRunner
extend TestRunnerUtilities
# Creates a new TestRunner for running the passed
# suite.
def initialize(suite, output_level = NORMAL)
if (suite.respond_to?(:suite))
@suite = suite.suite
else
@suite = suite
end
@result = nil
@runner = Thread.current
@restart_signal = Class.new(Exception)
@viewer = Thread.start do
@runner.join rescue @runner.run
Gtk.main
end
@viewer.join rescue nil # wait deadlock to handshake
end
# Begins the test run.
def start
setup_mediator
setup_ui
attach_to_mediator
start_ui
@result
end
private
def setup_mediator # :nodoc:
@mediator = TestRunnerMediator.new(@suite)
suite_name = @suite.to_s
if ( @suite.kind_of?(Module) )
suite_name = @suite.name
end
suite_name_entry.set_text(suite_name)
end
def attach_to_mediator # :nodoc:
run_button.signal_connect("clicked", nil, &method(:run_test))
@mediator.add_listener(TestRunnerMediator::RESET, &method(:reset_ui))
@mediator.add_listener(TestResult::FAULT, &method(:add_fault))
@mediator.add_listener(TestResult::CHANGED, &method(:result_changed))
@mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@mediator.add_listener(TestCase::STARTED, &method(:test_started))
@mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
@mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
end
def run_test(*)
@runner.raise(@restart_signal)
end
def start_ui # :nodoc:
@viewer.run
running = false
begin
loop do
if (running ^= true)
run_button.child.text = "Stop"
@mediator.run_suite
else
run_button.child.text = "Run"
@viewer.join
break
end
end
rescue @restart_signal
retry
rescue
end
end
def stop(*) # :nodoc:
Gtk.main_quit
end
def reset_ui(count) # :nodoc:
test_progress_bar.set_style(green_style)
test_progress_bar.configure(0, 0, count)
@red = false
run_count_label.set_text("0")
assertion_count_label.set_text("0")
failure_count_label.set_text("0")
error_count_label.set_text("0")
fault_list.remove_items(fault_list.children)
end
def add_fault(fault) # :nodoc:
if ( ! @red )
test_progress_bar.set_style(red_style)
@red = true
end
item = FaultListItem.new(fault)
item.show
fault_list.append_items([item])
end
def show_fault(fault) # :nodoc:
raw_show_fault(fault.long_display)
end
def raw_show_fault(string) # :nodoc:
fault_detail_label.set_text(string)
outer_detail_sub_panel.queue_resize
end
def clear_fault # :nodoc:
raw_show_fault("")
end
def result_changed(result) # :nodoc:
run_count_label.set_text(result.run_count.to_s)
assertion_count_label.set_text(result.assertion_count.to_s)
failure_count_label.set_text(result.failure_count.to_s)
error_count_label.set_text(result.error_count.to_s)
end
def started(result) # :nodoc:
@result = result
output_status("Started...")
end
def test_started(test_name)
output_status("Running #{test_name}...")
end
def test_finished(test_name)
test_progress_bar.set_value(test_progress_bar.get_value + 1)
end
def finished(elapsed_time)
output_status("Finished in #{elapsed_time} seconds")
end
def output_status(string) # :nodoc:
status_entry.set_text(string)
end
def setup_ui # :nodoc:
main_window.signal_connect("destroy", nil, &method(:stop))
main_window.show_all
fault_list.signal_connect("select-child", nil) {
| list, item, data |
show_fault(item.fault)
}
fault_list.signal_connect("unselect-child", nil) {
clear_fault
}
@red = false
end
def main_window # :nodoc:
lazy_initialize(:main_window) {
@main_window = Gtk::Window.new(Gtk::WINDOW_TOPLEVEL)
@main_window.set_title("Test::Unit TestRunner")
@main_window.set_usize(800, 600)
@main_window.set_uposition(20, 20)
@main_window.set_policy(true, true, false)
@main_window.add(main_panel)
}
end
def main_panel # :nodoc:
lazy_initialize(:main_panel) {
@main_panel = Gtk::VBox.new(false, 0)
@main_panel.pack_start(suite_panel, false, false, 0)
@main_panel.pack_start(progress_panel, false, false, 0)
@main_panel.pack_start(info_panel, false, false, 0)
@main_panel.pack_start(list_panel, false, false, 0)
@main_panel.pack_start(detail_panel, true, true, 0)
@main_panel.pack_start(status_panel, false, false, 0)
}
end
def suite_panel # :nodoc:
lazy_initialize(:suite_panel) {
@suite_panel = Gtk::HBox.new(false, 10)
@suite_panel.border_width(10)
@suite_panel.pack_start(Gtk::Label.new("Suite:"), false, false, 0)
@suite_panel.pack_start(suite_name_entry, true, true, 0)
@suite_panel.pack_start(run_button, false, false, 0)
}
end
def suite_name_entry # :nodoc:
lazy_initialize(:suite_name_entry) {
@suite_name_entry = Gtk::Entry.new
@suite_name_entry.set_editable(false)
}
end
def run_button # :nodoc:
lazy_initialize(:run_button) {
@run_button = Gtk::Button.new("Run")
}
end
def progress_panel # :nodoc:
lazy_initialize(:progress_panel) {
@progress_panel = Gtk::HBox.new(false, 10)
@progress_panel.border_width(10)
@progress_panel.pack_start(test_progress_bar, true, true, 0)
}
end
def test_progress_bar # :nodoc:
lazy_initialize(:test_progress_bar) {
@test_progress_bar = EnhancedProgressBar.new
@test_progress_bar.set_usize(@test_progress_bar.allocation.width,
info_panel.size_request.height)
@test_progress_bar.set_style(green_style)
}
end
def green_style # :nodoc:
lazy_initialize(:green_style) {
@green_style = Gtk::Style.new
@green_style.set_bg(Gtk::STATE_PRELIGHT, 0x0000, 0xFFFF, 0x0000)
}
end
def red_style # :nodoc:
lazy_initialize(:red_style) {
@red_style = Gtk::Style.new
@red_style.set_bg(Gtk::STATE_PRELIGHT, 0xFFFF, 0x0000, 0x0000)
}
end
def info_panel # :nodoc:
lazy_initialize(:info_panel) {
@info_panel = Gtk::HBox.new(false, 0)
@info_panel.border_width(10)
@info_panel.pack_start(Gtk::Label.new("Runs:"), false, false, 0)
@info_panel.pack_start(run_count_label, true, false, 0)
@info_panel.pack_start(Gtk::Label.new("Assertions:"), false, false, 0)
@info_panel.pack_start(assertion_count_label, true, false, 0)
@info_panel.pack_start(Gtk::Label.new("Failures:"), false, false, 0)
@info_panel.pack_start(failure_count_label, true, false, 0)
@info_panel.pack_start(Gtk::Label.new("Errors:"), false, false, 0)
@info_panel.pack_start(error_count_label, true, false, 0)
}
end
def run_count_label # :nodoc:
lazy_initialize(:run_count_label) {
@run_count_label = Gtk::Label.new("0")
@run_count_label.set_justify(Gtk::JUSTIFY_LEFT)
}
end
def assertion_count_label # :nodoc:
lazy_initialize(:assertion_count_label) {
@assertion_count_label = Gtk::Label.new("0")
@assertion_count_label.set_justify(Gtk::JUSTIFY_LEFT)
}
end
def failure_count_label # :nodoc:
lazy_initialize(:failure_count_label) {
@failure_count_label = Gtk::Label.new("0")
@failure_count_label.set_justify(Gtk::JUSTIFY_LEFT)
}
end
def error_count_label # :nodoc:
lazy_initialize(:error_count_label) {
@error_count_label = Gtk::Label.new("0")
@error_count_label.set_justify(Gtk::JUSTIFY_LEFT)
}
end
def list_panel # :nodoc:
lazy_initialize(:list_panel) {
@list_panel = Gtk::HBox.new
@list_panel.border_width(10)
@list_panel.pack_start(list_scrolled_window, true, true, 0)
}
end
def list_scrolled_window # :nodoc:
lazy_initialize(:list_scrolled_window) {
@list_scrolled_window = Gtk::ScrolledWindow.new
@list_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
@list_scrolled_window.set_usize(@list_scrolled_window.allocation.width, 150)
@list_scrolled_window.add_with_viewport(fault_list)
}
end
def fault_list # :nodoc:
lazy_initialize(:fault_list) {
@fault_list = Gtk::List.new
}
end
def detail_panel # :nodoc:
lazy_initialize(:detail_panel) {
@detail_panel = Gtk::HBox.new
@detail_panel.border_width(10)
@detail_panel.pack_start(detail_scrolled_window, true, true, 0)
}
end
def detail_scrolled_window # :nodoc:
lazy_initialize(:detail_scrolled_window) {
@detail_scrolled_window = Gtk::ScrolledWindow.new
@detail_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
@detail_scrolled_window.set_usize(400, @detail_scrolled_window.allocation.height)
@detail_scrolled_window.add_with_viewport(outer_detail_sub_panel)
}
end
def outer_detail_sub_panel # :nodoc:
lazy_initialize(:outer_detail_sub_panel) {
@outer_detail_sub_panel = Gtk::VBox.new
@outer_detail_sub_panel.pack_start(inner_detail_sub_panel, false, false, 0)
}
end
def inner_detail_sub_panel # :nodoc:
lazy_initialize(:inner_detail_sub_panel) {
@inner_detail_sub_panel = Gtk::HBox.new
@inner_detail_sub_panel.pack_start(fault_detail_label, false, false, 0)
}
end
def fault_detail_label # :nodoc:
lazy_initialize(:fault_detail_label) {
@fault_detail_label = EnhancedLabel.new("")
style = Gtk::Style.new
font = Gdk::Font.font_load("-*-Courier New-medium-r-normal--*-120-*-*-*-*-*-*")
begin
style.set_font(font)
rescue ArgumentError; end
@fault_detail_label.set_style(style)
@fault_detail_label.set_justify(Gtk::JUSTIFY_LEFT)
@fault_detail_label.set_line_wrap(false)
}
end
def status_panel # :nodoc:
lazy_initialize(:status_panel) {
@status_panel = Gtk::HBox.new
@status_panel.border_width(10)
@status_panel.pack_start(status_entry, true, true, 0)
}
end
def status_entry # :nodoc:
lazy_initialize(:status_entry) {
@status_entry = Gtk::Entry.new
@status_entry.set_editable(false)
}
end
def lazy_initialize(symbol) # :nodoc:
if (!instance_eval("defined?(@#{symbol.to_s})"))
yield
end
return instance_eval("@" + symbol.to_s)
end
end
class EnhancedProgressBar < Gtk::ProgressBar # :nodoc: all
def set_style(style)
super
hide
show
end
end
class EnhancedLabel < Gtk::Label # :nodoc: all
def set_text(text)
super(text.gsub(/\n\t/, "\n" + (" " * 4)))
end
end
class FaultListItem < Gtk::ListItem # :nodoc: all
attr_reader(:fault)
def initialize(fault)
super(fault.short_display)
@fault = fault
end
end
end
end
end
end
if __FILE__ == $0
Test::Unit::UI::GTK::TestRunner.start_command_line_test
end

465
lib/test/unit/ui/gtk2/testrunner.rb
View file

@ -1,465 +0,0 @@
#--
#
# Author:: Kenta MURATA.
# Copyright:: Copyright (c) 2000-2002 Kenta MURATA. All rights reserved.
# License:: Ruby license.
require "gtk2"
require "test/unit/ui/testrunnermediator"
require "test/unit/ui/testrunnerutilities"
module Test
module Unit
module UI
module GTK2 # :nodoc: all
Gtk.init
class EnhancedLabel < Gtk::Label # :nodoc: all
def set_text(text)
super(text.gsub(/\n\t/, "\n "))
end
end
class FaultList < Gtk::TreeView # :nodoc: all
def initialize
@faults = []
@model = Gtk::ListStore.new(String, String)
super(@model)
column = Gtk::TreeViewColumn.new
column.visible = false
append_column(column)
renderer = Gtk::CellRendererText.new
column = Gtk::TreeViewColumn.new("Failures", renderer, {:text => 1})
append_column(column)
selection.mode = Gtk::SELECTION_SINGLE
set_rules_hint(true)
set_headers_visible(false)
end # def initialize
def add_fault(fault)
@faults.push(fault)
iter = @model.append
iter.set_value(0, (@faults.length - 1).to_s)
iter.set_value(1, fault.short_display)
end # def add_fault(fault)
def get_fault(iter)
@faults[iter.get_value(0).to_i]
end # def get_fault
def clear
model.clear
end # def clear
end
class TestRunner
extend TestRunnerUtilities
def lazy_initialize(symbol) # :nodoc:
if !instance_eval("defined?(@#{symbol})") then
yield
end
return instance_eval("@#{symbol}")
end
private :lazy_initialize
def status_entry # :nodoc:
lazy_initialize(:status_entry) do
@status_entry = Gtk::Entry.new
@status_entry.editable = false
end
end
private :status_entry
def status_panel # :nodoc:
lazy_initialize(:status_panel) do
@status_panel = Gtk::HBox.new
@status_panel.border_width = 10
@status_panel.pack_start(status_entry, true, true, 0)
end
end
private :status_panel
def fault_detail_label # :nodoc:
lazy_initialize(:fault_detail_label) do
@fault_detail_label = EnhancedLabel.new("")
# style = Gtk::Style.new
# font = Gdk::Font.
# font_load("-*-Courier 10 Pitch-medium-r-normal--*-120-*-*-*-*-*-*")
# style.set_font(font)
# @fault_detail_label.style = style
@fault_detail_label.justify = Gtk::JUSTIFY_LEFT
@fault_detail_label.wrap = false
end
end
private :fault_detail_label
def inner_detail_sub_panel # :nodoc:
lazy_initialize(:inner_detail_sub_panel) do
@inner_detail_sub_panel = Gtk::HBox.new
@inner_detail_sub_panel.pack_start(fault_detail_label, false, false, 0)
end
end
private :inner_detail_sub_panel
def outer_detail_sub_panel # :nodoc:
lazy_initialize(:outer_detail_sub_panel) do
@outer_detail_sub_panel = Gtk::VBox.new
@outer_detail_sub_panel.pack_start(inner_detail_sub_panel, false, false, 0)
end
end
private :outer_detail_sub_panel
def detail_scrolled_window # :nodoc:
lazy_initialize(:detail_scrolled_window) do
@detail_scrolled_window = Gtk::ScrolledWindow.new
@detail_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
@detail_scrolled_window.
set_size_request(400, @detail_scrolled_window.allocation.height)
@detail_scrolled_window.add_with_viewport(outer_detail_sub_panel)
end
end
private :detail_scrolled_window
def detail_panel # :nodoc:
lazy_initialize(:detail_panel) do
@detail_panel = Gtk::HBox.new
@detail_panel.border_width = 10
@detail_panel.pack_start(detail_scrolled_window, true, true, 0)
end
end
private :detail_panel
def fault_list # :nodoc:
lazy_initialize(:fault_list) do
@fault_list = FaultList.new
end
end
private :fault_list
def list_scrolled_window # :nodoc:
lazy_initialize(:list_scrolled_window) do
@list_scrolled_window = Gtk::ScrolledWindow.new
@list_scrolled_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC)
@list_scrolled_window.
set_size_request(@list_scrolled_window.allocation.width, 150)
@list_scrolled_window.add_with_viewport(fault_list)
end
end
private :list_scrolled_window
def list_panel # :nodoc:
lazy_initialize(:list_panel) do
@list_panel = Gtk::HBox.new
@list_panel.border_width = 10
@list_panel.pack_start(list_scrolled_window, true, true, 0)
end
end
private :list_panel
def error_count_label # :nodoc:
lazy_initialize(:error_count_label) do
@error_count_label = Gtk::Label.new("0")
@error_count_label.justify = Gtk::JUSTIFY_LEFT
end
end
private :error_count_label
def failure_count_label # :nodoc:
lazy_initialize(:failure_count_label) do
@failure_count_label = Gtk::Label.new("0")
@failure_count_label.justify = Gtk::JUSTIFY_LEFT
end
end
private :failure_count_label
def assertion_count_label # :nodoc:
lazy_initialize(:assertion_count_label) do
@assertion_count_label = Gtk::Label.new("0")
@assertion_count_label.justify = Gtk::JUSTIFY_LEFT
end
end
private :assertion_count_label
def run_count_label # :nodoc:
lazy_initialize(:run_count_label) do
@run_count_label = Gtk::Label.new("0")
@run_count_label.justify = Gtk::JUSTIFY_LEFT
end
end
private :run_count_label
def info_panel # :nodoc:
lazy_initialize(:info_panel) do
@info_panel = Gtk::HBox.new(false, 0)
@info_panel.border_width = 10
@info_panel.pack_start(Gtk::Label.new("Runs:"), false, false, 0)
@info_panel.pack_start(run_count_label, true, false, 0)
@info_panel.pack_start(Gtk::Label.new("Assertions:"), false, false, 0)
@info_panel.pack_start(assertion_count_label, true, false, 0)
@info_panel.pack_start(Gtk::Label.new("Failures:"), false, false, 0)
@info_panel.pack_start(failure_count_label, true, false, 0)
@info_panel.pack_start(Gtk::Label.new("Errors:"), false, false, 0)
@info_panel.pack_start(error_count_label, true, false, 0)
end
end # def info_panel
private :info_panel
def green_style # :nodoc:
lazy_initialize(:green_style) do
@green_style = Gtk::Style.new
@green_style.set_bg(Gtk::STATE_PRELIGHT, 0x0000, 0xFFFF, 0x0000)
end
end # def green_style
private :green_style
def red_style # :nodoc:
lazy_initialize(:red_style) do
@red_style = Gtk::Style.new
@red_style.set_bg(Gtk::STATE_PRELIGHT, 0xFFFF, 0x0000, 0x0000)
end
end # def red_style
private :red_style
def test_progress_bar # :nodoc:
lazy_initialize(:test_progress_bar) {
@test_progress_bar = Gtk::ProgressBar.new
@test_progress_bar.fraction = 0.0
@test_progress_bar.
set_size_request(@test_progress_bar.allocation.width,
info_panel.size_request[1])
@test_progress_bar.style = green_style
}
end # def test_progress_bar
private :test_progress_bar
def progress_panel # :nodoc:
lazy_initialize(:progress_panel) do
@progress_panel = Gtk::HBox.new(false, 10)
@progress_panel.border_width = 10
@progress_panel.pack_start(test_progress_bar, true, true, 0)
end
end # def progress_panel
def run_button # :nodoc:
lazy_initialize(:run_button) do
@run_button = Gtk::Button.new("Run")
end
end # def run_button
def suite_name_entry # :nodoc:
lazy_initialize(:suite_name_entry) do
@suite_name_entry = Gtk::Entry.new
@suite_name_entry.editable = false
end
end # def suite_name_entry
private :suite_name_entry
def suite_panel # :nodoc:
lazy_initialize(:suite_panel) do
@suite_panel = Gtk::HBox.new(false, 10)
@suite_panel.border_width = 10
@suite_panel.pack_start(Gtk::Label.new("Suite:"), false, false, 0)
@suite_panel.pack_start(suite_name_entry, true, true, 0)
@suite_panel.pack_start(run_button, false, false, 0)
end
end # def suite_panel
private :suite_panel
def main_panel # :nodoc:
lazy_initialize(:main_panel) do
@main_panel = Gtk::VBox.new(false, 0)
@main_panel.pack_start(suite_panel, false, false, 0)
@main_panel.pack_start(progress_panel, false, false, 0)
@main_panel.pack_start(info_panel, false, false, 0)
@main_panel.pack_start(list_panel, false, false, 0)
@main_panel.pack_start(detail_panel, true, true, 0)
@main_panel.pack_start(status_panel, false, false, 0)
end
end # def main_panel
private :main_panel
def main_window # :nodoc:
lazy_initialize(:main_window) do
@main_window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
@main_window.set_title("Test::Unit TestRunner")
@main_window.set_default_size(800, 600)
@main_window.set_resizable(true)
@main_window.add(main_panel)
end
end # def main_window
private :main_window
def setup_ui # :nodoc:
main_window.signal_connect("destroy", nil) { stop }
main_window.show_all
fault_list.selection.signal_connect("changed", nil) do
|selection, data|
if selection.selected then
show_fault(fault_list.get_fault(selection.selected))
else
clear_fault
end
end
end # def setup_ui
private :setup_ui
def output_status(string) # :nodoc:
status_entry.set_text(string)
end # def output_status(string)
private :output_status
def finished(elapsed_time) # :nodoc:
test_progress_bar.fraction = 1.0
output_status("Finished in #{elapsed_time} seconds")
end # def finished(elapsed_time)
private :finished
def test_started(test_name) # :nodoc:
output_status("Running #{test_name}...")
end # def test_started(test_name)
private :test_started
def started(result) # :nodoc:
@result = result
output_status("Started...")
end # def started(result)
private :started
def test_finished(result) # :nodoc:
test_progress_bar.fraction += 1.0 / @count
end # def test_finished(result)
def result_changed(result) # :nodoc:
run_count_label.label = result.run_count.to_s
assertion_count_label.label = result.assertion_count.to_s
failure_count_label.label = result.failure_count.to_s
error_count_label.label = result.error_count.to_s
end # def result_changed(result)
private :result_changed
def clear_fault # :nodoc:
raw_show_fault("")
end # def clear_fault
private :clear_fault
def raw_show_fault(string) # :nodoc:
fault_detail_label.set_text(string)
outer_detail_sub_panel.queue_resize
end # def raw_show_fault(string)
private :raw_show_fault
def show_fault(fault) # :nodoc:
raw_show_fault(fault.long_display)
end # def show_fault(fault)
private :show_fault
def add_fault(fault) # :nodoc:
if not @red then
test_progress_bar.style = red_style
@red = true
end
fault_list.add_fault(fault)
end # def add_fault(fault)
private :add_fault
def reset_ui(count) # :nodoc:
test_progress_bar.style = green_style
test_progress_bar.fraction = 0.0
@count = count + 1
@red = false
run_count_label.set_text("0")
assertion_count_label.set_text("0")
failure_count_label.set_text("0")
error_count_label.set_text("0")
fault_list.clear
end # def reset_ui(count)
private :reset_ui
def stop # :nodoc:
Gtk.main_quit
end # def stop
private :stop
def run_test
@runner.raise(@restart_signal)
end
private :run_test
def start_ui # :nodoc
@viewer.run
running = false
begin
loop do
if (running ^= true)
run_button.child.text = "Stop"
@mediator.run_suite
else
run_button.child.text = "Run"
@viewer.join
break
end
end
rescue @restart_signal
retry
rescue
end
end # def start_ui
private :start_ui
def attach_to_mediator
run_button.signal_connect("clicked", nil) { run_test }
@mediator.add_listener(TestRunnerMediator::RESET, &method(:reset_ui))
@mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
@mediator.add_listener(TestResult::FAULT, &method(:add_fault))
@mediator.add_listener(TestResult::CHANGED, &method(:result_changed))
@mediator.add_listener(TestCase::STARTED, &method(:test_started))
@mediator.add_listener(TestCase::FINISHED, &method(:test_finished))
end # def attach_to_mediator
private :attach_to_mediator
def setup_mediator
@mediator = TestRunnerMediator.new(@suite)
suite_name = @suite.to_s
if @suite.kind_of?(Module) then
suite_name = @suite.name
end
suite_name_entry.set_text(suite_name)
end # def setup_mediator
private :setup_mediator
def start
setup_mediator
setup_ui
attach_to_mediator
start_ui
@result
end # def start
def initialize(suite, output_level = NORMAL)
if suite.respond_to?(:suite) then
@suite = suite.suite
else
@suite = suite
end
@result = nil
@runner = Thread.current
@restart_signal = Class.new(Exception)
@viewer = Thread.start do
@runner.join rescue @runner.run
Gtk.main
end
@viewer.join rescue nil # wait deadlock to handshake
end # def initialize(suite)
end # class TestRunner
end # module GTK2
end # module UI
end # module Unit
end # module Test

68
lib/test/unit/ui/testrunnermediator.rb
View file

@ -1,68 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit'
require 'test/unit/util/observable'
require 'test/unit/testresult'
module Test
module Unit
module UI # :nodoc:
# Provides an interface to write any given UI against,
# hopefully making it easy to write new UIs.
class TestRunnerMediator
RESET = name + "::RESET"
STARTED = name + "::STARTED"
FINISHED = name + "::FINISHED"
include Util::Observable
# Creates a new TestRunnerMediator initialized to run
# the passed suite.
def initialize(suite)
@suite = suite
end
# Runs the suite the TestRunnerMediator was created
# with.
def run_suite
Unit.run = true
begin_time = Time.now
notify_listeners(RESET, @suite.size)
result = create_result
notify_listeners(STARTED, result)
result_listener = result.add_listener(TestResult::CHANGED) do |updated_result|
notify_listeners(TestResult::CHANGED, updated_result)
end
fault_listener = result.add_listener(TestResult::FAULT) do |fault|
notify_listeners(TestResult::FAULT, fault)
end
@suite.run(result) do |channel, value|
notify_listeners(channel, value)
end
result.remove_listener(TestResult::FAULT, fault_listener)
result.remove_listener(TestResult::CHANGED, result_listener)
end_time = Time.now
elapsed_time = end_time - begin_time
notify_listeners(FINISHED, elapsed_time) #"Finished in #{elapsed_time} seconds.")
return result
end
private
# A factory method to create the result the mediator
# should run with. Can be overridden by subclasses if
# one wants to use a different result.
def create_result
return TestResult.new
end
end
end
end
end

46
lib/test/unit/ui/testrunnerutilities.rb
View file

@ -1,46 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
module Test
module Unit
module UI
SILENT = 0
PROGRESS_ONLY = 1
NORMAL = 2
VERBOSE = 3
# Provides some utilities common to most, if not all,
# TestRunners.
#
#--
#
# Perhaps there ought to be a TestRunner superclass? There
# seems to be a decent amount of shared code between test
# runners.
module TestRunnerUtilities
# Creates a new TestRunner and runs the suite.
def run(suite, output_level=NORMAL)
return new(suite, output_level).start
end
# Takes care of the ARGV parsing and suite
# determination necessary for running one of the
# TestRunners from the command line.
def start_command_line_test
if ARGV.empty?
puts "You should supply the name of a test suite file to the runner"
exit
end
require ARGV[0].gsub(/.+::/, '')
new(eval(ARGV[0])).start
end
end
end
end
end

260
lib/test/unit/ui/tk/testrunner.rb
View file

@ -1,260 +0,0 @@
#--
#
# Original Author:: Nathaniel Talbott.
# Author:: Kazuhiro NISHIYAMA.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# Copyright:: Copyright (c) 2003 Kazuhiro NISHIYAMA. All rights reserved.
# License:: Ruby license.
require 'tk'
require 'test/unit/ui/testrunnermediator'
require 'test/unit/ui/testrunnerutilities'
module Test
module Unit
module UI
module Tk # :nodoc:
# Runs a Test::Unit::TestSuite in a Tk UI. Obviously,
# this one requires you to have Tk
# and the Ruby Tk extension installed.
class TestRunner
extend TestRunnerUtilities
# Creates a new TestRunner for running the passed
# suite.
def initialize(suite, output_level = NORMAL)
if (suite.respond_to?(:suite))
@suite = suite.suite
else
@suite = suite
end
@result = nil
@red = false
@fault_detail_list = []
@runner = Thread.current
@restart_signal = Class.new(Exception)
@viewer = Thread.start do
@runner.join rescue @runner.run
::Tk.mainloop
end
@viewer.join rescue nil # wait deadlock to handshake
end
# Begins the test run.
def start
setup_ui
setup_mediator
attach_to_mediator
start_ui
@result
end
private
def setup_mediator # :nodoc:
@mediator = TestRunnerMediator.new(@suite)
suite_name = @suite.to_s
if ( @suite.kind_of?(Module) )
suite_name = @suite.name
end
@suite_name_entry.value = suite_name
end
def attach_to_mediator # :nodoc:
@run_button.command(method(:run_test))
@fault_list.bind('ButtonPress-1', proc{|y|
fault = @fault_detail_list[@fault_list.nearest(y)]
if fault
show_fault(fault)
end
}, '%y')
@mediator.add_listener(TestRunnerMediator::RESET, &method(:reset_ui))
@mediator.add_listener(TestResult::FAULT, &method(:add_fault))
@mediator.add_listener(TestResult::CHANGED, &method(:result_changed))
@mediator.add_listener(TestRunnerMediator::STARTED, &method(:started))
@mediator.add_listener(TestCase::STARTED, &method(:test_started))
@mediator.add_listener(TestRunnerMediator::FINISHED, &method(:finished))
end
def run_test
@runner.raise(@restart_signal)
end
def start_ui # :nodoc:
@viewer.run
running = false
begin
loop do
if (running ^= true)
@run_button.configure('text'=>'Stop')
@mediator.run_suite
else
@run_button.configure('text'=>'Run')
@viewer.join
break
end
end
rescue @restart_signal
retry
rescue
end
end
def stop # :nodoc:
::Tk.exit
end
def reset_ui(count) # :nodoc:
@test_total_count = count.to_f
@test_progress_bar.configure('background'=>'green')
@test_progress_bar.place('relwidth'=>(count.zero? ? 0 : 0/count))
@red = false
@test_count_label.value = 0
@assertion_count_label.value = 0
@failure_count_label.value = 0
@error_count_label.value = 0
@fault_list.delete(0, 'end')
@fault_detail_list = []
clear_fault
end
def add_fault(fault) # :nodoc:
if ( ! @red )
@test_progress_bar.configure('background'=>'red')
@red = true
end
@fault_detail_list.push fault
@fault_list.insert('end', fault.short_display)
end
def show_fault(fault) # :nodoc:
raw_show_fault(fault.long_display)
end
def raw_show_fault(string) # :nodoc:
@detail_text.value = string
end
def clear_fault # :nodoc:
raw_show_fault("")
end
def result_changed(result) # :nodoc:
@test_count_label.value = result.run_count
@test_progress_bar.place('relwidth'=>result.run_count/@test_total_count)
@assertion_count_label.value = result.assertion_count
@failure_count_label.value = result.failure_count
@error_count_label.value = result.error_count
end
def started(result) # :nodoc:
@result = result
output_status("Started...")
end
def test_started(test_name)
output_status("Running #{test_name}...")
end
def finished(elapsed_time)
output_status("Finished in #{elapsed_time} seconds")
end
def output_status(string) # :nodoc:
@status_entry.value = string
end
def setup_ui # :nodoc:
@status_entry = TkVariable.new
l = TkLabel.new(nil, 'textvariable'=>@status_entry, 'relief'=>'sunken')
l.pack('side'=>'bottom', 'fill'=>'x')
suite_frame = TkFrame.new.pack('fill'=>'x')
@run_button = TkButton.new(suite_frame, 'text'=>'Run')
@run_button.pack('side'=>'right')
TkLabel.new(suite_frame, 'text'=>'Suite:').pack('side'=>'left')
@suite_name_entry = TkVariable.new
l = TkLabel.new(suite_frame, 'textvariable'=>@suite_name_entry, 'relief'=>'sunken')
l.pack('side'=>'left', 'fill'=>'x', 'expand'=>true)
f = TkFrame.new(nil, 'relief'=>'sunken', 'borderwidth'=>3, 'height'=>20).pack('fill'=>'x', 'padx'=>1)
@test_progress_bar = TkFrame.new(f, 'background'=>'green').place('anchor'=>'nw', 'relwidth'=>0.0, 'relheight'=>1.0)
info_frame = TkFrame.new.pack('fill'=>'x')
@test_count_label = create_count_label(info_frame, 'Tests:')
@assertion_count_label = create_count_label(info_frame, 'Assertions:')
@failure_count_label = create_count_label(info_frame, 'Failures:')
@error_count_label = create_count_label(info_frame, 'Errors:')
if (::Tk.info('command', TkPanedWindow::TkCommandNames[0]) != "")
# use panedwindow
paned_frame = TkPanedWindow.new("orient"=>"vertical").pack('fill'=>'both', 'expand'=>true)
fault_list_frame = TkFrame.new(paned_frame)
detail_frame = TkFrame.new(paned_frame)
paned_frame.add(fault_list_frame, detail_frame)
else
# no panedwindow
paned_frame = nil
fault_list_frame = TkFrame.new.pack('fill'=>'both', 'expand'=>true)
detail_frame = TkFrame.new.pack('fill'=>'both', 'expand'=>true)
end
TkGrid.rowconfigure(fault_list_frame, 0, 'weight'=>1, 'minsize'=>0)
TkGrid.columnconfigure(fault_list_frame, 0, 'weight'=>1, 'minsize'=>0)
fault_scrollbar_y = TkScrollbar.new(fault_list_frame)
fault_scrollbar_x = TkScrollbar.new(fault_list_frame)
@fault_list = TkListbox.new(fault_list_frame)
@fault_list.yscrollbar(fault_scrollbar_y)
@fault_list.xscrollbar(fault_scrollbar_x)
TkGrid.rowconfigure(detail_frame, 0, 'weight'=>1, 'minsize'=>0)
TkGrid.columnconfigure(detail_frame, 0, 'weight'=>1, 'minsize'=>0)
::Tk.grid(@fault_list, fault_scrollbar_y, 'sticky'=>'news')
::Tk.grid(fault_scrollbar_x, 'sticky'=>'news')
detail_scrollbar_y = TkScrollbar.new(detail_frame)
detail_scrollbar_x = TkScrollbar.new(detail_frame)
@detail_text = TkText.new(detail_frame, 'height'=>10, 'wrap'=>'none') {
bindtags(bindtags - [TkText])
}
@detail_text.yscrollbar(detail_scrollbar_y)
@detail_text.xscrollbar(detail_scrollbar_x)
::Tk.grid(@detail_text, detail_scrollbar_y, 'sticky'=>'news')
::Tk.grid(detail_scrollbar_x, 'sticky'=>'news')
# rubber-style pane
if paned_frame
::Tk.update
@height = paned_frame.winfo_height
paned_frame.bind('Configure', proc{|h|
paned_frame.sash_place(0, 0, paned_frame.sash_coord(0)[1] * h / @height)
@height = h
}, '%h')
end
end
def create_count_label(parent, label) # :nodoc:
TkLabel.new(parent, 'text'=>label).pack('side'=>'left', 'expand'=>true)
v = TkVariable.new(0)
TkLabel.new(parent, 'textvariable'=>v).pack('side'=>'left', 'expand'=>true)
v
end
end
end
end
end
end
if __FILE__ == $0
Test::Unit::UI::Tk::TestRunner.start_command_line_test
end

40
lib/test/unit/util/backtracefilter.rb
View file

@ -1,40 +0,0 @@
module Test
module Unit
module Util
module BacktraceFilter
TESTUNIT_FILE_SEPARATORS = %r{[\\/:]}
TESTUNIT_PREFIX = __FILE__.split(TESTUNIT_FILE_SEPARATORS)[0..-3]
TESTUNIT_RB_FILE = /\.rb\Z/
def filter_backtrace(backtrace, prefix=nil)
return ["No backtrace"] unless(backtrace)
split_p = if(prefix)
prefix.split(TESTUNIT_FILE_SEPARATORS)
else
TESTUNIT_PREFIX
end
match = proc do |e|
split_e = e.split(TESTUNIT_FILE_SEPARATORS)[0, split_p.size]
next false unless(split_e[0..-2] == split_p[0..-2])
split_e[-1].sub(TESTUNIT_RB_FILE, '') == split_p[-1]
end
return backtrace unless(backtrace.detect(&match))
found_prefix = false
new_backtrace = backtrace.reverse.reject do |e|
if(match[e])
found_prefix = true
true
elsif(found_prefix)
false
else
true
end
end.reverse
new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
new_backtrace = new_backtrace.reject(&match)
new_backtrace.empty? ? backtrace : new_backtrace
end
end
end
end
end

90
lib/test/unit/util/observable.rb
View file

@ -1,90 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
require 'test/unit/util/procwrapper'
module Test
module Unit
module Util # :nodoc:
# This is a utility class that allows anything mixing
# it in to notify a set of listeners about interesting
# events.
module Observable
# We use this for defaults since nil might mean something
NOTHING = "NOTHING/#{__id__}"
# Adds the passed proc as a listener on the
# channel indicated by channel_name. listener_key
# is used to remove the listener later; if none is
# specified, the proc itself is used.
#
# Whatever is used as the listener_key is
# returned, making it very easy to use the proc
# itself as the listener_key:
#
# listener = add_listener("Channel") { ... }
# remove_listener("Channel", listener)
def add_listener(channel_name, listener_key=NOTHING, &listener) # :yields: value
unless(block_given?)
raise ArgumentError.new("No callback was passed as a listener")
end
key = listener_key
if (listener_key == NOTHING)
listener_key = listener
key = ProcWrapper.new(listener)
end
channels[channel_name] ||= {}
channels[channel_name][key] = listener
return listener_key
end
# Removes the listener indicated by listener_key
# from the channel indicated by
# channel_name. Returns the registered proc, or
# nil if none was found.
def remove_listener(channel_name, listener_key)
channel = channels[channel_name]
return nil unless (channel)
key = listener_key
if (listener_key.instance_of?(Proc))
key = ProcWrapper.new(listener_key)
end
if (channel.has_key?(key))
return channel.delete(key)
end
return nil
end
# Calls all the procs registered on the channel
# indicated by channel_name. If value is
# specified, it is passed in to the procs,
# otherwise they are called with no arguments.
#
#--
#
# Perhaps this should be private? Would it ever
# make sense for an external class to call this
# method directly?
def notify_listeners(channel_name, *arguments)
channel = channels[channel_name]
return 0 unless (channel)
listeners = channel.values
listeners.each { |listener| listener.call(*arguments) }
return listeners.size
end
private
def channels # :nodoc:
@channels ||= {}
return @channels
end
end
end
end
end

48
lib/test/unit/util/procwrapper.rb
View file

@ -1,48 +0,0 @@
#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.
module Test
module Unit
module Util
# Allows the storage of a Proc passed through '&' in a
# hash.
#
# Note: this may be inefficient, since the hash being
# used is not necessarily very good. In Observable,
# efficiency is not too important, since the hash is
# only accessed when adding and removing listeners,
# not when notifying.
class ProcWrapper
# Creates a new wrapper for a_proc.
def initialize(a_proc)
@a_proc = a_proc
@hash = a_proc.inspect.sub(/^(#<#{a_proc.class}:)/, '').sub(/(>)$/, '').hex
end
def hash # :nodoc:
return @hash
end
def ==(other) # :nodoc:
case(other)
when ProcWrapper
return @a_proc == other.to_proc
else
return super
end
end
alias :eql? :==
def to_proc # :nodoc:
return @a_proc
end
end
end
end
end

18
test/runner.rb
View file

@ -1,19 +1,5 @@
require 'rbconfig'
exit if CROSS_COMPILING
require 'test/unit'
rcsid = %w$Id$
Version = rcsid[2].scan(/\d+/).collect!(&method(:Integer)).freeze
Release = rcsid[3].freeze
# this allows minitest and test/unit to run side by side. test/unit
# tests with fork/signal were triggering minitest multiple times.
require 'minitest/unit'
MiniTest::Unit.disable_autorun
args = ARGV.dup
result = Test::Unit::AutoRunner.run(true, File.dirname($0))
result &&= MiniTest::Unit.new.run(args)
exit result
Test::Unit.setup_argv