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