summaryrefslogtreecommitdiff
path: root/lib/test/unit
diff options
context:
space:
mode:
Diffstat (limited to 'lib/test/unit')
-rw-r--r--lib/test/unit/assertionfailederror.rb14
-rw-r--r--lib/test/unit/assertions.rb444
-rw-r--r--lib/test/unit/autorunner.rb178
-rw-r--r--lib/test/unit/collector.rb43
-rw-r--r--lib/test/unit/collector/dir.rb80
-rw-r--r--lib/test/unit/collector/objectspace.rb34
-rw-r--r--lib/test/unit/error.rb56
-rw-r--r--lib/test/unit/failure.rb51
-rw-r--r--lib/test/unit/testcase.rb150
-rw-r--r--lib/test/unit/testresult.rb81
-rw-r--r--lib/test/unit/testsuite.rb76
-rw-r--r--lib/test/unit/ui/console/testrunner.rb137
-rw-r--r--lib/test/unit/ui/fox/testrunner.rb270
-rw-r--r--lib/test/unit/ui/gtk/testrunner.rb389
-rw-r--r--lib/test/unit/ui/testrunnermediator.rb67
-rw-r--r--lib/test/unit/ui/testrunnerutilities.rb36
-rw-r--r--lib/test/unit/util/backtracefilter.rb39
-rw-r--r--lib/test/unit/util/observable.rb90
-rw-r--r--lib/test/unit/util/procwrapper.rb48
19 files changed, 0 insertions, 2283 deletions
diff --git a/lib/test/unit/assertionfailederror.rb b/lib/test/unit/assertionfailederror.rb
deleted file mode 100644
index 9b9e53f16c..0000000000
--- a/lib/test/unit/assertionfailederror.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# :nodoc:
-#
-# 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 < Exception
- end
- end
-end
diff --git a/lib/test/unit/assertions.rb b/lib/test/unit/assertions.rb
deleted file mode 100644
index fdb9632e09..0000000000
--- a/lib/test/unit/assertions.rb
+++ /dev/null
@@ -1,444 +0,0 @@
-# :nodoc:
-#
-# 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:
-
- # Contains all of the standard Test::Unit assertions. Mixed in
- # to Test::Unit::TestCase. To mix it in and use its
- # functionality, you simply need to rescue
- # Test::Unit::AssertionFailedError, and you can additionally
- # override add_assertion to be notified whenever an assertion
- # is made.
- #
- # Notes:
- # * The message to each assertion, if given, will be
- # propagated with the failure.
- # * It's easy to add your own assertions based on assert_block().
- module Assertions
-
- # The assertion upon which all other assertions are
- # based. Passes if the block yields true.
- public
- def assert_block(message="assert_block failed.") # :yields:
- _wrap_assertion do
- if (! yield)
- raise AssertionFailedError.new(message.to_s)
- end
- end
- end
-
- # Passes if boolean is true.
- 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.
- 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
-
- # Passes if block raises exception.
- public
- def assert_raises(expected_exception_klass, message="")
- _wrap_assertion do
- assert_instance_of(Class, expected_exception_klass, "Should expect a class of exception")
- actual_exception = nil
- full_message = build_message(message, "<?> exception expected but none was thrown.", expected_exception_klass)
- assert_block(full_message) do
- thrown = false
- begin
- yield
- rescue Exception => thrown_exception
- actual_exception = thrown_exception
- thrown = true
- end
- thrown
- end
- full_message = build_message(message, "<?> exception expected but was\n?", expected_exception_klass, actual_exception)
- assert_block(full_message) { expected_exception_klass == actual_exception.class }
- actual_exception
- end
- end
-
- # Passes if object.class == klass.
- 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.nil?.
- public
- def assert_nil(object, message="")
- assert_equal(nil, object, message)
- end
-
- # Passes if object.kind_of?(klass).
- 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\\?<?>.", object, klass)
- assert_block(full_message){object.kind_of?(klass)}
- end
- end
-
- # Passes if object.respond_to?(method) is true.
- 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.
- 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).
- 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 two objects based on the passed
- # operator. Passes if object1.send(operator, object2) is
- # true.
- 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.
- public
- def assert_nothing_raised(*args)
- _wrap_assertion do
- message = ""
- if (!args[-1].instance_of?(Class))
- message = args.pop
- end
- begin
- yield
- rescue Exception => e
- if ((args.empty? && !e.instance_of?(AssertionFailedError)) || args.include?(e.class))
- assert_block(build_message(message, "Exception raised:\n?", e)){false}
- else
- raise e.class, e.message, e.backtrace
- end
- end
- nil
- end
- end
-
- # Always fails.
- public
- def flunk(message="Flunked")
- assert_block(build_message(message)){false}
- end
-
- # Passes if !actual.equal?(expected).
- 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.
- 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?.
- public
- def assert_not_nil(object, message="")
- warn("Assertions#assert_not_nil is deprecated and will be removed after 1.8.1. Use #assert.")
- full_message = build_message(message, "<?> expected to not be nil.", object)
- assert_block(full_message){!object.nil?}
- end
-
- # Passes if string !~ regularExpression.
- public
- def assert_no_match(regexp, string, message="")
- _wrap_assertion do
- assert_instance_of(Regexp, regexp, "The first argument to assert_does_not_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
-
- # Passes if block throws symbol.
- public
- def assert_throws(expected_symbol, message="", &proc)
- _wrap_assertion do
- assert_instance_of(Symbol, expected_symbol, "assert_throws expects the symbol that should be thrown for its first argument")
- assert_block("Should have passed a block to assert_throws."){block_given?}
- caught = true
- begin
- catch(expected_symbol) do
- proc.call
- caught = false
- end
- full_message = build_message(message, "<?> should have been thrown.", expected_symbol)
- assert_block(full_message){caught}
- rescue NameError => name_error
- if ( name_error.message !~ /^uncaught throw `(.+)'$/ ) #`
- raise name_error
- end
- full_message = build_message(message, "<?> expected to be thrown but\n<?> was thrown.", expected_symbol, $1.intern)
- flunk(full_message)
- end
- end
- end
-
- # Passes if block does not throw anything.
- 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 NameError => name_error
- if (name_error.message !~ /^uncaught throw `(.+)'$/ ) #`
- raise name_error
- end
- full_message = build_message(message, "<?> was thrown when nothing was expected", $1.intern)
- 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.
- 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 sent returns a true value.
- 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
-
- 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.
- private
- def add_assertion
- end
-
- # Select whether or not to use the prettyprinter. If this
- # option is set to false before any assertions are made, the
- # prettyprinter will not be required at all.
- public
- def self.use_pp=(value)
- AssertionMessage.use_pp = value
- end
-
- class AssertionMessage # :nodoc: all
- @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
- end
- end
-end
diff --git a/lib/test/unit/autorunner.rb b/lib/test/unit/autorunner.rb
deleted file mode 100644
index be32e47f6e..0000000000
--- a/lib/test/unit/autorunner.rb
+++ /dev/null
@@ -1,178 +0,0 @@
-require 'optparse'
-
-require 'test/unit/ui/console/testrunner'
-
-module Test
- module Unit
- class AutoRunner
- def self.run(current_file=nil, default_dir=nil, &block)
- if(!current_file || current_file == $0)
- r = new(!current_file, &block)
- if(default_dir && r.to_run.empty?)
- r.to_run = default_dir
- end
- r.run
- end
- end
-
- RUNNERS = {
- :console => proc do |r|
- output_level = r.output_level || Test::Unit::UI::Console::TestRunner::NORMAL
- passed = Test::Unit::UI::Console::TestRunner.run(r.suite, output_level).passed?
- exit(passed ? 0 : 1)
- end,
- :gtk => proc do |r|
- require 'test/unit/ui/gtk/testrunner'
- Test::Unit::UI::GTK::TestRunner.run(r.suite)
- end,
- :fox => proc do |suite|
- require 'test/unit/ui/fox/testrunner'
- Test::Unit::UI::Fox::TestRunner.run(r.suite)
- end,
- }
-
- OUTPUT_LEVELS = {
- :silent => UI::Console::TestRunner::SILENT,
- :progress => UI::Console::TestRunner::PROGRESS_ONLY,
- :normal => UI::Console::TestRunner::NORMAL,
- :verbose => UI::Console::TestRunner::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 = r.pattern if(r.pattern)
- c.collect(*(r.to_run.empty? ? ['.'] : r.to_run))
- end,
- }
-
- attr_reader :suite
- attr_accessor :output_level, :filters, :to_run, :pattern
- attr_writer :runner, :collector
-
- def initialize(standalone)
- Unit.run = true
- @standalone = standalone
- @runner = RUNNERS[:console]
- @collector = COLLECTORS[(standalone ? :dir : :objectspace)]
- @filters = []
- @to_run = []
- process_args
- yield(self) if(block_given?)
- end
-
- def process_args
- catch(:stop_processing) do
- ARGV.options do |o|
- o.program_name = "test/unit.rb"
- o.banner = "Test::Unit automatic runner."
- o.banner = "#{$0} [options] [-- untouched arguments]"
-
- o.on
- o.on('-r', '--runner=RUNNER', RUNNERS.keys,
- "Use the given RUNNER.",
- "(" + keyword_display(RUNNERS.keys) + ")") do |r|
- @runner = runners[r]
- end
-
- if(@standalone)
- 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
-
- o.on('-p', '--pattern=PATTERN', String,
- "Match files to collect against PATTERN.") do |e|
- @pattern = Regexp.new(e.sub(%r{\A/(.*)/\Z}m, '\\1'))
- 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('-v', '--verbose=[LEVEL]', OUTPUT_LEVELS.keys,
- "Set the output level (default is verbose).",
- "(" + keyword_display(OUTPUT_LEVELS.keys) + ")") do |l|
- @output_level = (l ? OUTPUT_LEVELS[l] : OUTPUT_LEVELS[:verbose])
- end
-
- o.on('--',
- "Stop processing options so that the",
- "remaining options will be passed to the",
- "test."){throw :stop_processing}
-
- o.on('-h', '--help', 'Display this help.'){puts o; exit(0)}
-
- 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
-
- begin
- o.parse!
- rescue OptionParser::ParseError => e
- puts e
- puts o
- exit(1)
- end
- end
- end
- @filters << proc{false} unless(@filters.empty?)
- end
-
- def keyword_display(array)
- array.collect{|e| e.to_s.sub(/^(.)(.+)$/, '\\1[\\2]')}.join(", ")
- end
-
- def run
- @suite = @collector[self]
- @runner[self]
- end
- end
- end
-end
diff --git a/lib/test/unit/collector.rb b/lib/test/unit/collector.rb
deleted file mode 100644
index 9e9e654147..0000000000
--- a/lib/test/unit/collector.rb
+++ /dev/null
@@ -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
diff --git a/lib/test/unit/collector/dir.rb b/lib/test/unit/collector/dir.rb
deleted file mode 100644
index b5c935519e..0000000000
--- a/lib/test/unit/collector/dir.rb
+++ /dev/null
@@ -1,80 +0,0 @@
-require 'test/unit/testsuite'
-require 'test/unit/collector'
-
-module Test
- module Unit
- module Collector
- class Dir
- include Collector
-
- attr_writer :pattern
-
- def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
- super()
- @dir = dir
- @file = file
- @object_space = object_space
- @req = req
- @pattern = /\Atest_.*\.rb\Z/m
- end
-
- def collect(*from)
- 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
- end
-
- def find_test_cases(ignore=[])
- cases = []
- @object_space.each_object(Class) do |c|
- cases << c if(c < TestCase && !ignore.include?(c))
- end
- ignore.concat(cases)
- cases
- end
-
- def recursive_collect(name, already_gathered)
- sub_suites = []
- if(@file.directory?(name))
- @dir.entries(name).each do |e|
- next if(e == '.' || e == '..')
- e_name = @file.join(name, e)
- if(@file.directory?(e_name))
- sub_suite = recursive_collect(e_name, already_gathered)
- sub_suites << sub_suite unless(sub_suite.empty?)
- else
- (next unless(@pattern =~ e)) if(@pattern)
- 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)
- if(@req)
- @req.require(name)
- else
- require(name)
- end
- find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
- end
- end
- end
- end
-end
diff --git a/lib/test/unit/collector/objectspace.rb b/lib/test/unit/collector/objectspace.rb
deleted file mode 100644
index d1127a981f..0000000000
--- a/lib/test/unit/collector/objectspace.rb
+++ /dev/null
@@ -1,34 +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 Collector
-
- NAME = 'collected from the ObjectSpace'
-
- def initialize(source=::ObjectSpace)
- super()
- @source = source
- end
-
- def collect(name=NAME)
- suite = TestSuite.new(name)
- sub_suites = []
- @source.each_object(Class) do |klass|
- if(Test::Unit::TestCase > klass)
- add_suite(sub_suites, klass.suite)
- end
- end
- sort(sub_suites).each{|s| suite << s}
- suite
- end
- end
- end
- end
-end
diff --git a/lib/test/unit/error.rb b/lib/test/unit/error.rb
deleted file mode 100644
index 90ac04cf3b..0000000000
--- a/lib/test/unit/error.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# :nodoc:
-#
-# 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
diff --git a/lib/test/unit/failure.rb b/lib/test/unit/failure.rb
deleted file mode 100644
index 42cc9d4b8c..0000000000
--- a/lib/test/unit/failure.rb
+++ /dev/null
@@ -1,51 +0,0 @@
-# :nodoc:
-#
-# 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
diff --git a/lib/test/unit/testcase.rb b/lib/test/unit/testcase.rb
deleted file mode 100644
index f258c23ca1..0000000000
--- a/lib/test/unit/testcase.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-# :nodoc:
-#
-# 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"
-
- # 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)
- 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 StandardError, ScriptError
- add_error($!)
- ensure
- begin
- teardown
- rescue AssertionFailedError => e
- add_failure(e.message, e.backtrace)
- rescue StandardError, ScriptError
- 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
-
- # Overriden 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
diff --git a/lib/test/unit/testresult.rb b/lib/test/unit/testresult.rb
deleted file mode 100644
index b1bfbf72e4..0000000000
--- a/lib/test/unit/testresult.rb
+++ /dev/null
@@ -1,81 +0,0 @@
-# :nodoc:
-#
-# 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
diff --git a/lib/test/unit/testsuite.rb b/lib/test/unit/testsuite.rb
deleted file mode 100644
index b3a704ec63..0000000000
--- a/lib/test/unit/testsuite.rb
+++ /dev/null
@@ -1,76 +0,0 @@
-# :nodoc:
-#
-# 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
-
- # Overriden 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
diff --git a/lib/test/unit/ui/console/testrunner.rb b/lib/test/unit/ui/console/testrunner.rb
deleted file mode 100644
index dab07ddbc4..0000000000
--- a/lib/test/unit/ui/console/testrunner.rb
+++ /dev/null
@@ -1,137 +0,0 @@
-# :nodoc:
-#
-# 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
-
- SILENT = 0
- PROGRESS_ONLY = 1
- NORMAL = 2
- VERBOSE = 3
-
- # Creates a new TestRunner and runs the suite.
- def self.run(suite, output_level=NORMAL)
- return new(suite, output_level).start
- end
-
- # 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)
- 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
diff --git a/lib/test/unit/ui/fox/testrunner.rb b/lib/test/unit/ui/fox/testrunner.rb
deleted file mode 100644
index 8b82ec634d..0000000000
--- a/lib/test/unit/ui/fox/testrunner.rb
+++ /dev/null
@@ -1,270 +0,0 @@
-# :nodoc:
-#
-# 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 and runs the suite.
- def self.run(suite)
- new(suite).start
- end
-
- # Creates a new TestRunner for running the passed
- # suite.
- def initialize(suite)
- if (suite.respond_to?(:suite))
- @suite = suite.suite
- else
- @suite = suite
- end
-
- @red = false
- end
-
- # Begins the test run.
- def start
- setup_ui
- setup_mediator
- attach_to_mediator
- start_ui
- 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:
- 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
diff --git a/lib/test/unit/ui/gtk/testrunner.rb b/lib/test/unit/ui/gtk/testrunner.rb
deleted file mode 100644
index 229df3e358..0000000000
--- a/lib/test/unit/ui/gtk/testrunner.rb
+++ /dev/null
@@ -1,389 +0,0 @@
-# :nodoc:
-#
-# 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 and runs the suite.
- def self.run(suite)
- new(suite).start
-
- end
-
- # Creates a new TestRunner for running the passed
- # suite.
- def initialize(suite)
- if (suite.respond_to?(:suite))
- @suite = suite.suite
- else
- @suite = suite
- end
- end
-
- # Begins the test run.
- def start
- setup_mediator
- setup_ui
- attach_to_mediator
- start_ui
- 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) { @mediator.run_suite }
- @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:
- timer = Gtk::timeout_add(0) {
- Gtk::timeout_remove(timer)
- @mediator.run_suite
- }
- Gtk.main
- 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.longDisplay)
- end
-
- def raw_show_fault(string) # :nodoc:
- faultDetailLabel.set_text(string)
- outerDetailSubPanel.queue_resize
- end
-
- def clear_fault # :nodoc:
- raw_show_fault("")
- end
-
- def result_changed(result) # :nodoc:
- test_progress_bar.set_value(test_progress_bar.get_value + 1)
-
- 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:
- 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.set_text(string)
- end
-
- def setup_ui # :nodoc:
- main_window.signal_connect("destroy", nil) { 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, 50)
- @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-*-*-*-*-*-*")
- style.set_font(font)
- @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
diff --git a/lib/test/unit/ui/testrunnermediator.rb b/lib/test/unit/ui/testrunnermediator.rb
deleted file mode 100644
index bd051e2a51..0000000000
--- a/lib/test/unit/ui/testrunnermediator.rb
+++ /dev/null
@@ -1,67 +0,0 @@
-# :nodoc:
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-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
diff --git a/lib/test/unit/ui/testrunnerutilities.rb b/lib/test/unit/ui/testrunnerutilities.rb
deleted file mode 100644
index 69811608c2..0000000000
--- a/lib/test/unit/ui/testrunnerutilities.rb
+++ /dev/null
@@ -1,36 +0,0 @@
-# :nodoc:
-#
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-module Test
- module Unit
- module UI
-
- # 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
-
- # 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
diff --git a/lib/test/unit/util/backtracefilter.rb b/lib/test/unit/util/backtracefilter.rb
deleted file mode 100644
index 3a423aa6a1..0000000000
--- a/lib/test/unit/util/backtracefilter.rb
+++ /dev/null
@@ -1,39 +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)
- 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
diff --git a/lib/test/unit/util/observable.rb b/lib/test/unit/util/observable.rb
deleted file mode 100644
index f5066d3425..0000000000
--- a/lib/test/unit/util/observable.rb
+++ /dev/null
@@ -1,90 +0,0 @@
-# :nodoc:
-#
-# 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
diff --git a/lib/test/unit/util/procwrapper.rb b/lib/test/unit/util/procwrapper.rb
deleted file mode 100644
index fea66d7671..0000000000
--- a/lib/test/unit/util/procwrapper.rb
+++ /dev/null
@@ -1,48 +0,0 @@
-# :nodoc:
-#
-# 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
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-05 04:46:57 +0000