diff options
Diffstat (limited to 'ruby_1_8_5/test/testunit/runit/test_assert.rb')
| -rw-r--r-- | ruby_1_8_5/test/testunit/runit/test_assert.rb | 402 |
1 files changed, 402 insertions, 0 deletions
diff --git a/ruby_1_8_5/test/testunit/runit/test_assert.rb b/ruby_1_8_5/test/testunit/runit/test_assert.rb new file mode 100644 index 0000000000..a3e62b2b2d --- /dev/null +++ b/ruby_1_8_5/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 |