* 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

ChangeLog

@@ -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

lib/rubyunit.rb

@@ -4,5 +4,3 @@
 
 require 'runit/testcase'
 require 'test/unit'
-
-TestCase = RUNIT::TestCase

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

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

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

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

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