diff options
author | ntalbott <ntalbott@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2003-10-05 02:17:07 +0000 |
---|---|---|
committer | ntalbott <ntalbott@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> | 2003-10-05 02:17:07 +0000 |
commit | b60827ba047b594dea58adf68f4e983f21c32c04 (patch) | |
tree | fb22b342c09e128badede324be27d35a57ba0d74 | |
parent | 0cf763af9c99cace8b4a44ce8160269931d207d2 (diff) | |
download | ruby-b60827ba047b594dea58adf68f4e983f21c32c04.tar.gz |
* lib/rubyunit.rb: aliasing TestCase into the top level is
problematic.
* lib/runit/assert.rb: fixed a couple of bugs caused by recent
refactoring in Test::Unit.
* test/testunit/runit/*: added.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4689 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
-rw-r--r-- | ChangeLog | 10 | ||||
-rw-r--r-- | lib/rubyunit.rb | 2 | ||||
-rw-r--r-- | lib/runit/assert.rb | 16 | ||||
-rw-r--r-- | test/testunit/runit/test_assert.rb | 402 | ||||
-rw-r--r-- | test/testunit/runit/test_testcase.rb | 91 | ||||
-rw-r--r-- | test/testunit/runit/test_testresult.rb | 160 | ||||
-rw-r--r-- | test/testunit/runit/test_testsuite.rb | 49 |
7 files changed, 721 insertions, 9 deletions
@@ -1,3 +1,13 @@ +Sun Oct 5 11:14:00 2003 Nathaniel Talbott <ntalbott@ruby-lang.org> + + * lib/rubyunit.rb: aliasing TestCase into the top level is + problematic. + + * lib/runit/assert.rb: fixed a couple of bugs caused by recent + refactoring in Test::Unit. + + * test/testunit/runit/*: added. + Sun Oct 5 10:55:29 2003 NAKAMURA, Hiroshi <nahi@ruby-lang.org> * lib/open-uri.rb (URI::Generic#find_proxy): no_proxy support did not diff --git a/lib/rubyunit.rb b/lib/rubyunit.rb index 8f1086c81d..1aca37864f 100644 --- a/lib/rubyunit.rb +++ b/lib/rubyunit.rb @@ -4,5 +4,3 @@ require 'runit/testcase' require 'test/unit' - -TestCase = RUNIT::TestCase diff --git a/lib/runit/assert.rb b/lib/runit/assert.rb index ede7df1c92..c752b19a25 100644 --- a/lib/runit/assert.rb +++ b/lib/runit/assert.rb @@ -16,15 +16,13 @@ module RUNIT assert_nothing_raised(*args, &block) end - # To deal with the fact that RubyUnit does not check that the regular expression - # is, indeed, a regular expression, if it is not, we do our own assertion using - # the same semantics as RubyUnit + # To deal with the fact that RubyUnit does not check that the + # regular expression is, indeed, a regular expression, if it is + # not, we do our own assertion using the same semantics as + # RubyUnit def assert_match(actual_string, expected_re, message="") _wrap_assertion { - full_message = build_message(message, actual_string, expected_re) { - | arg1, arg2 | - "Expected <#{arg1}> to match <#{arg2}>" - } + full_message = build_message(message, "Expected <?> to match <?>", actual_string, expected_re) assert_block(full_message) { expected_re =~ actual_string } @@ -32,6 +30,10 @@ module RUNIT } end + def assert_not_nil(actual, message="") + assert(!actual.nil?, message) + end + def assert_not_match(actual_string, expected_re, message="") assert_no_match(expected_re, actual_string, message) end diff --git a/test/testunit/runit/test_assert.rb b/test/testunit/runit/test_assert.rb new file mode 100644 index 0000000000..a3e62b2b2d --- /dev/null +++ b/test/testunit/runit/test_assert.rb @@ -0,0 +1,402 @@ +# Author:: Masaki Suketa. +# Adapted by:: Nathaniel Talbott. +# Copyright:: Copyright (c) Masaki Suketa. All rights reserved. +# Copyright:: Copyright (c) 2002 Nathaniel Talbott. All rights reserved. +# License:: Ruby license. + +require 'rubyunit' + +module RUNIT + class TargetAssert + include RUNIT::Assert + end + + class TestAssert < RUNIT::TestCase + def setup + @assert = TargetAssert.new + @e = nil + end + + def test_assert + sub_test_assert_pass(true) + sub_test_assert_pass(TRUE) + sub_test_assert_failure(false) + sub_test_assert_failure(FALSE) + sub_test_assert_failure(nil) + sub_test_assert_pass("") + sub_test_assert_pass("ok") + sub_test_assert_pass(0) + sub_test_assert_pass(1) + end + + def test_assert_with_2_argument + assert_no_exception { + assert(true, "3") + } + assert_no_exception { + assert(true) + } + end + + def test_assert_equal_float_0_1 + assert_proc = Proc.new { + @assert.assert_equal_float(1.4, 1.35, 0.1) + } + sub_assert_pass(assert_proc) + end + + def test_assert_equal_float_0_5 + assert_proc = Proc.new { + @assert.assert_equal_float(1.4, 1.34, 0.5) + } + sub_assert_pass(assert_proc) + end + + def test_assert_equal_float_0 + assert_proc = Proc.new { + @assert.assert_equal_float(1.4, 1.4, 0) + } + sub_assert_pass(assert_proc) + end + + def test_assert_equal_float_0_raise + assert_proc = Proc.new { + @assert.assert_equal_float(1.4, 1.34, 0) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_equal_float_0_01 + assert_proc = Proc.new { + @assert.assert_equal_float(1.4, 1.35, 0.01) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_equal_float_0_001 + assert_proc = Proc.new { + @assert.assert_equal_float(Math.sqrt(2), 1.414, 0.001) + } + sub_assert_pass(assert_proc) + end + + def test_assert_equal_float_minus_1_0 + assert_proc = Proc.new { + @assert.assert_equal_float(1.4, 1.35, -1.0) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_fail + except = nil + begin + @assert.assert_fail("failure") + rescue Exception + except = $! + end + assert_not_nil(except) + end + + def sub_test_assert_pass(obj) + assert_proc = Proc.new { + @assert.assert(obj) + } + sub_assert_pass(assert_proc) + end + + def sub_test_assert_failure(obj) + assert_proc = Proc.new { + @assert.assert(obj) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_equal + assert_proc = Proc.new { + @assert.assert_equal(2, 2) + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_equal(2, 3) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_nil + obj = nil + assert_proc = Proc.new { + @assert.assert_nil(obj) + } + sub_assert_pass(assert_proc) + obj = 'string' + sub_assert_raise_fail(assert_proc) + end + + def test_assert_not_nil + obj = 'string' + assert_proc = Proc.new { + @assert.assert_not_nil(obj) + } + sub_assert_pass(assert_proc) + + obj = nil + sub_assert_raise_fail(assert_proc) + end + + def test_assert_operator + assert_proc = Proc.new { + @assert.assert_operator(2, :<, 3) + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_operator(2, :>, 3) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_respond_to + sub_test_assert_respond_to('string', 'sub', 'foo') + sub_test_assert_respond_to('string', :sub, :foo) + end + + def sub_test_assert_respond_to(obj, msg, dummy_msg) + assert_proc = Proc.new { + @assert.assert_respond_to(msg, obj) + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_respond_to(dummy_msg, obj) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_send + assert_proc = Proc.new { + ary = [] + @assert.assert_send ary, :empty? + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + ary = [2,3] + @assert.assert_send ary, :empty? + } + sub_assert_raise_fail(assert_proc) + assert_proc = Proc.new { + str = "abc" + @assert.assert_send str, :sub!, "z", "y" + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_kind_of + assert_proc = Proc.new { + @assert.assert_kind_of(String, "string") + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_kind_of(Regexp, "string") + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_instance_of + assert_proc = Proc.new { + @assert.assert_instance_of(String, "string") + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_instance_of(Object, "string") + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_match + assert_proc = Proc.new{ + @assert.assert_match('foostring', /foo/) + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_match('barstring', /foo/) + } + sub_assert_raise_fail(assert_proc) + match = @assert.assert_match('foostring', /foo/) + assert_instance_of(MatchData, match) + assert_equal('foo', match[0]) + end + + def test_assert_matches + assert_proc = Proc.new{ + @assert.assert_matches('foostring', /foo/) + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_matches('barstring', /foo/) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_not_match + assert_proc = Proc.new{ + @assert.assert_not_match('barstring', /foo/) + } + sub_assert_pass(assert_proc) + assert_proc = Proc.new { + @assert.assert_not_match('foostring', /foo/) + } + sub_assert_raise_fail(assert_proc) + assert_proc = Proc.new { + @assert.assert_not_match('foobarbaz', /ba.+/) + } + sub_assert_raise_fail(assert_proc) + end + + def test_assert_same + flag = false + e = "foo" + a = e + assert_proc = Proc.new {@assert.assert_same(e, a)} + sub_assert_pass(assert_proc) + + a = "foo" + sub_assert_raise_fail(assert_proc) + end + + def test_assert_exception + assert_proc = Proc.new{ + @assert.assert_exception(IOError) { + raise IOError + } + } + sub_assert_pass(assert_proc) + + assert_proc = Proc.new{ + @assert.assert_exception(StandardError) { + raise IOError + } + } + sub_assert_raise_fail(assert_proc) + + assert_proc = Proc.new{ + @assert.assert_exception(IOError, "Exception") { + raise StandardError + } + } + sub_assert_raise_fail(assert_proc) + + assert_proc = Proc.new { + @assert.assert_exception(StandardError) { + "No Exception raised in this block" + } + } + sub_assert_raise_fail(assert_proc) + + assert_proc = Proc.new { + @assert.assert_exception(StandardError) { + exit(33) + } + } + sub_assert_raise_fail(assert_proc) + + t = @assert.assert_exception(IOError) { + raise IOError + } + assert_instance_of(IOError, t) + t = @assert.assert_exception(NameError) { + non_existent_method + } + assert_instance_of(NameError, t) + t = @assert.assert_exception(SystemExit) { + exit(33) + } + assert_instance_of(SystemExit, t) + end + + def test_assert_no_exception + assert_proc = Proc.new{ + @assert.assert_no_exception(IOError, ArgumentError) { + "No Exception raised in this block" + } + } + sub_assert_pass(assert_proc) + + assert_proc = Proc.new{ + @assert.assert_no_exception(IOError, ArgumentError) { + raise StandardError, "Standard Error raised" + } + } + sub_assert_raise_error(assert_proc) + + assert_proc = Proc.new{ + @assert.assert_no_exception(IOError, ArgumentError) { + raise ArgumentError, "Bad Argument" + } + } + sub_assert_raise_fail(assert_proc) + + assert_proc = Proc.new{ + @assert.assert_no_exception { + raise ArgumentError, "Bad Argument" + } + } + sub_assert_raise_fail(assert_proc) + + assert_proc = Proc.new{ + @assert.assert_no_exception { + raise NameError, "Bad Name" + } + } + sub_assert_raise_fail(assert_proc) + assert_proc = Proc.new { + @assert.assert_no_exception { + raise NoMemoryError + } + } + sub_assert_raise_fail(assert_proc) + end + + def sub_assert_pass(p) + flag = false + err = nil + begin + p.call + flag = true + rescue + err = $! + flag = false + end + assert(flag, err.to_s) + end + + def sub_assert_raise_fail(p) + flag = false + err = nil + begin + p.call + flag = false + rescue RUNIT::AssertionFailedError + flag = true + err = $! + rescue Exception + flag = false + err = $! + end + assert(flag, err.to_s) + end + + def sub_assert_raise_error(p) + flag = false + err = nil + begin + p.call + flag = false + rescue RUNIT::AssertionFailedError + flag = false + err = $! + rescue Exception + flag = true + err = $! + end + assert(flag, err.to_s) + end + end +end diff --git a/test/testunit/runit/test_testcase.rb b/test/testunit/runit/test_testcase.rb new file mode 100644 index 0000000000..f57e0386e3 --- /dev/null +++ b/test/testunit/runit/test_testcase.rb @@ -0,0 +1,91 @@ +# Author:: Masaki Suketa. +# Adapted by:: Nathaniel Talbott. +# Copyright:: Copyright (c) Masaki Suketa. All rights reserved. +# Copyright:: Copyright (c) 2002 Nathaniel Talbott. All rights reserved. +# License:: Ruby license. + +require 'rubyunit' + +module RUNIT + class DummyError < StandardError + end + + class TestTestCase < RUNIT::TestCase + def setup + @dummy_testcase = Class.new(RUNIT::TestCase) do + def self.name + "DummyTestCase" + end + + attr_reader :status, :dummy_called, :dummy2_called + + def initialize(*arg) + super(*arg) + @status = 0 + @dummy_called = false + @dummy2_called = false + end + + def setup + @status = 1 if @status == 0 + end + + def test_dummy + @status = 2 if @status == 1 + @dummy_called = true + end + + def test_dummy2 + @status = 2 if @status == 1 + @dummy2_called = true + raise DummyError + end + + def teardown + @status = 3 if @status == 2 + end + end + + @test1 = @dummy_testcase.new('test_dummy') + @test2 = @dummy_testcase.new('test_dummy2', 'TestCase') + end + + def test_name + assert_equal('DummyTestCase#test_dummy', @test1.name) # The second parameter to #initialize is ignored in emulation + assert_equal('DummyTestCase#test_dummy2', @test2.name) + end + + def test_run + result = RUNIT::TestResult.new + @test1.run(result) + assert_equal(1, result.run_count) + end + + def test_s_suite + suite = @dummy_testcase.suite + assert_instance_of(RUNIT::TestSuite, suite) + assert_equal(2, suite.count_test_cases) + end + + def test_teardown_err + suite = Class.new(RUNIT::TestCase) do + def test_foo + assert(false) + end + + def test_bar + assert(true) + end + + def teardown + raise StandardError + end + end.suite + + result = RUNIT::TestResult.new + suite.run(result) + assert_equal(2, result.error_size) + assert_equal(1, result.failure_size) + end + end +end diff --git a/test/testunit/runit/test_testresult.rb b/test/testunit/runit/test_testresult.rb new file mode 100644 index 0000000000..9249309f35 --- /dev/null +++ b/test/testunit/runit/test_testresult.rb @@ -0,0 +1,160 @@ +# Author:: Masaki Suketa. +# Adapted by:: Nathaniel Talbott. +# Copyright:: Copyright (c) Masaki Suketa. All rights reserved. +# Copyright:: Copyright (c) 2002 Nathaniel Talbott. All rights reserved. +# License:: Ruby license. + +require 'runit/testcase' +require 'runit/cui/testrunner' + +require 'runit/testresult' + +module RUNIT + class TestTestResult < RUNIT::TestCase + def setup + @result = RUNIT::TestResult.new + + @normal_suite = Class::new(RUNIT::TestCase) do + def test_1 + assert(true) + assert(true) + end + end.suite + + @failure_suite = Class::new(RUNIT::TestCase) do + def test_1 + assert(true) + assert(false) + end + end.suite + + @error_suite = Class::new(RUNIT::TestCase) do + def setup + raise ScriptError + end + def test_1 + assert(true) + end + end.suite + + @multi_failure_suite = Class::new(RUNIT::TestCase) do + def test1 + assert(false) + end + def test2 + assert(false) + end + def test3 + assert(false) + end + end.suite + + @with_error_suite = Class::new(RUNIT::TestCase) do + def test1 + raise StandardError + end + end.suite + + @multi_error_suite = Class::new(RUNIT::TestCase) do + def test1 + raise StandardError + end + def test2 + raise StandardError + end + def test3 + raise StandardError + end + end.suite + + @multi_suite = Class::new(RUNIT::TestCase) do + def test_1 + assert(true) + assert(true) + end + def test_2 + assert(true) + end + def test_3 + assert(true) + assert(false) + assert(true) + end + end.suite + end + + def test_error_size + @normal_suite.run(@result) + assert_equal(0, @result.error_size) + @with_error_suite.run(@result) + assert_equal(1, @result.error_size) + @multi_error_suite.run(@result) + assert_equal(4, @result.error_size) + end + + def test_errors + @normal_suite.run(@result) + assert_equal(0, @result.errors.size) + end + + def test_failure_size + @normal_suite.run(@result) + assert_equal(0, @result.failure_size) + @failure_suite.run(@result) + assert_equal(1, @result.failure_size) + @multi_failure_suite.run(@result) + assert_equal(4, @result.failure_size) + end + + def test_failures + @normal_suite.run(@result) + assert_equal(0, @result.failures.size) + @failure_suite.run(@result) + assert_equal(1, @result.failures.size) + @multi_failure_suite.run(@result) + assert_equal(4, @result.failures.size) + end + + def test_run_no_exception + assert_no_exception { + @error_suite.run(@result) + } + end + + def test_run_asserts + @normal_suite.run(@result) + assert_equal(2, @result.run_asserts) + end + + def test_run_asserts2 + @failure_suite.run(@result) + assert_equal(2, @result.run_asserts) + end + + def test_run_tests + assert_equal(0, @result.run_tests) + @normal_suite.run(@result) + assert_equal(1, @result.run_tests) + @multi_suite.run(@result) + assert_equal(4, @result.run_tests) + end + + def test_succeed? + @normal_suite.run(@result) + assert(@result.succeed?) + end + end + + if $0 == __FILE__ + testrunner = RUNIT::CUI::TestRunner.new + if ARGV.size == 0 + suite = TestRUNIT__TestResult.suite + else + suite = RUNIT::TestSuite.new + ARGV.each do |testmethod| + suite.add(TestRUNIT__TestResult.new(testmethod)) + end + end + testrunner.run(suite) + end +end diff --git a/test/testunit/runit/test_testsuite.rb b/test/testunit/runit/test_testsuite.rb new file mode 100644 index 0000000000..58702d3efe --- /dev/null +++ b/test/testunit/runit/test_testsuite.rb @@ -0,0 +1,49 @@ +# Author:: Masaki Suketa. +# Adapted by:: Nathaniel Talbott. +# Copyright:: Copyright (c) Masaki Suketa. All rights reserved. +# Copyright:: Copyright (c) 2002 Nathaniel Talbott. All rights reserved. +# License:: Ruby license. + +require 'rubyunit' + +module RUNIT + class TestTestSuite < RUNIT::TestCase + def setup + @testsuite = RUNIT::TestSuite.new + @dummy_test = Class.new(RUNIT::TestCase) do + def test_foo + end + def test_bar + end + end + @dummy_empty_test = Class.new(RUNIT::TestCase){} + end + + def test_count_test_cases + assert_equal(0, @testsuite.count_test_cases) + + @testsuite.add(@dummy_empty_test.suite) + assert_equal(0, @testsuite.count_test_cases) + + @testsuite.add(@dummy_test.suite) + assert_equal(2, @testsuite.count_test_cases) + + @testsuite.add(@dummy_test.suite) + assert_equal(4, @testsuite.count_test_cases) + + dummytest_foo = @dummy_test.new('test_foo') + @testsuite.add(dummytest_foo) + assert_equal(5, @testsuite.count_test_cases) + end + + def test_add + @testsuite.add(@dummy_empty_test.suite) + assert_equal(0, @testsuite.size) + assert_equal(0, @testsuite.count_test_cases) + + @testsuite.add(@dummy_test.suite) + assert_equal(2, @testsuite.size) + assert_equal(2, @testsuite.count_test_cases) + end + end +end |