summaryrefslogtreecommitdiff
path: root/ruby_1_8_5/test/testunit/runit/test_assert.rb
diff options
context:
space:
mode:
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.rb402
1 files changed, 0 insertions, 402 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
deleted file mode 100644
index a3e62b2b2d..0000000000
--- a/ruby_1_8_5/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