test-unit 1.2.3

data/test/test_error.rb

@@ -0,0 +1,26 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+
+module Test
+  module Unit
+    class TC_Error < TestCase
+      TF_Exception = Struct.new('TF_Exception', :message, :backtrace)
+      def test_display
+        ex = TF_Exception.new("message1\nmessage2", ['line1', 'line2'])
+        e = Error.new("name", ex)
+        assert_equal("name: #{TF_Exception.name}: message1", e.short_display)
+        assert_equal(<<EOM.strip, e.long_display)
+Error:
+name:
+Struct::TF_Exception: message1
+message2
+    line1
+    line2
+EOM
+      end
+    end
+  end
+end

data/test/test_failure.rb

@@ -0,0 +1,33 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+require 'test/unit/failure'
+
+module Test::Unit
+  class TestFailure < TestCase
+    def test_display
+      f = Failure.new("name", [%q{location:1 in 'l'}], "message1\nmessage2")
+      assert_equal("name: message1", f.short_display)
+      assert_equal(<<EOM.strip, f.long_display)
+Failure:
+name [location:1]:
+message1
+message2
+EOM
+
+      f = Failure.new("name", [%q{location1:2 in 'l1'}, 'location2:1', %q{location3:3 in 'l3'}], "message1\nmessage2")
+      assert_equal("name: message1", f.short_display)
+      assert_equal(<<EOM.strip, f.long_display)
+Failure:
+name
+    [location1:2 in 'l1'
+     location2:1
+     location3:3 in 'l3']:
+message1
+message2
+EOM
+    end
+  end
+end

data/test/test_testcase.rb

@@ -0,0 +1,275 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+
+module Test
+  module Unit
+    class TC_TestCase < TestCase
+      def test_creation
+        tc = Class.new(TestCase) do
+          def test_with_arguments(arg1, arg2)
+          end
+        end
+      
+        caught = true
+        catch(:invalid_test) do
+          tc.new(:test_with_arguments)
+          caught = false
+        end
+        check("Should have caught an invalid test when there are arguments", caught)
+        
+        caught = true
+        catch(:invalid_test) do
+          tc.new(:non_existent_test)
+          caught = false
+        end
+        check("Should have caught an invalid test when the method does not exist", caught)
+      end
+      
+      def setup
+        @tc_failure_error = Class.new(TestCase) do
+          def test_failure
+            assert_block("failure") { false }
+          end
+          def test_error
+            1 / 0
+          end
+          def test_nested_failure
+            nested
+          end
+          def nested
+            assert_block("nested"){false}
+          end
+          def return_passed?
+            return passed?
+          end
+        end
+
+        def @tc_failure_error.name
+          "TC_FailureError"
+        end
+      end
+ 
+      def test_add_failed_assertion
+        test_case = @tc_failure_error.new(:test_failure)
+        check("passed? should start out true", test_case.return_passed?)
+        result = TestResult.new
+        called = false
+        result.add_listener(TestResult::FAULT) {
+          | fault |
+          check("Should have a Failure", fault.instance_of?(Failure))
+          check("The Failure should have the correct message", "failure" == fault.message)
+          check("The Failure should have the correct test_name (was <#{fault.test_name}>)", fault.test_name == "test_failure(TC_FailureError)")
+          r = /\A.*#{Regexp.escape(File.basename(__FILE__))}:\d+:in `test_failure'\Z/
+
+          location = fault.location
+          check("The location should be an array", location.kind_of?(Array))
+          check("The location should have two lines (was: <#{location.inspect}>)", location.size == 2)
+          check("The Failure should have the correct location (was <#{location[0].inspect}>, expected <#{r.inspect}>)", r =~ location[0])
+          called = true
+        }
+        progress = []
+        test_case.run(result) { |*arguments| progress << arguments }
+        check("The failure should have triggered the listener", called)
+        check("The failure should have set passed?", !test_case.return_passed?)
+        check("The progress block should have been updated correctly", [[TestCase::STARTED, test_case.name], [TestCase::FINISHED, test_case.name]] == progress)
+      end
+
+      def test_add_failure_nested
+        test_case = @tc_failure_error.new(:test_nested_failure)
+        check("passed? should start out true", test_case.return_passed?)
+
+        result = TestResult.new
+        called = false
+        result.add_listener(TestResult::FAULT) {
+          | fault |
+          check("Should have a Failure", fault.instance_of?(Failure))
+          check("The Failure should have the correct message", "nested" == fault.message)
+          check("The Failure should have the correct test_name (was <#{fault.test_name}>)", fault.test_name == "test_nested_failure(TC_FailureError)")
+          r = 
+
+          location = fault.location
+          check("The location should be an array", location.kind_of?(Array))
+          check("The location should have the correct number of lines (was: <#{location.inspect}>)", location.size == 3)
+          check("The Failure should have the correct location (was <#{location[0].inspect}>)", /\A.*#{Regexp.escape(File.basename(__FILE__))}:\d+:in `nested'\Z/ =~ location[0])
+          check("The Failure should have the correct location (was <#{location[1].inspect}>)", /\A.*#{Regexp.escape(File.basename(__FILE__))}:\d+:in `test_nested_failure'\Z/ =~ location[1])
+          called = true
+        }
+        test_case.run(result){}
+        check("The failure should have triggered the listener", called)
+      end
+      
+      def test_add_error
+        test_case = @tc_failure_error.new(:test_error)
+        check("passed? should start out true", test_case.return_passed?)
+        result = TestResult.new
+        called = false
+        result.add_listener(TestResult::FAULT) {
+          | fault |
+          check("Should have a TestError", fault.instance_of?(Error))
+          check("The Error should have the correct message", "ZeroDivisionError: divided by 0" == fault.message)
+          check("The Error should have the correct test_name", "test_error(TC_FailureError)" == fault.test_name)
+          check("The Error should have the correct exception", fault.exception.instance_of?(ZeroDivisionError))
+          called = true
+        }
+        test_case.run(result) {}
+        check("The error should have triggered the listener", called)
+        check("The error should have set passed?", !test_case.return_passed?)
+      end
+
+      def test_no_tests      
+        suite = TestCase.suite
+        check("Should have a test suite", suite.instance_of?(TestSuite))
+        check("Should have one test", suite.size == 1)
+        check("Should have the default test", suite.tests.first.name == "default_test(Test::Unit::TestCase)")
+        
+        result = TestResult.new
+        suite.run(result) {}
+        check("Should have had one test run", result.run_count == 1)
+        check("Should have had one test failure", result.failure_count == 1)
+        check("Should have had no errors", result.error_count == 0)
+      end
+
+      def test_suite
+        tc = Class.new(TestCase) do
+          def test_succeed
+            assert_block {true}
+          end
+          def test_fail
+            assert_block {false}
+          end
+          def test_error
+            1/0
+          end
+          def dont_run
+            assert_block {true}
+          end
+          def test_dont_run(argument)
+            assert_block {true}
+          end
+          def test
+            assert_block {true}
+          end
+        end
+      
+        suite = tc.suite
+        check("Should have a test suite", suite.instance_of?(TestSuite))
+        check("Should have three tests", suite.size == 3)
+  
+        result = TestResult.new
+        suite.run(result) {}
+        check("Should have had three test runs", result.run_count == 3)
+        check("Should have had one test failure", result.failure_count == 1)
+        check("Should have had one test error", result.error_count == 1)
+      end
+      
+     
+      def test_setup_teardown
+        tc = Class.new(TestCase) do
+          attr_reader(:setup_called, :teardown_called)
+          def initialize(test)
+            super(test)
+            @setup_called = false
+            @teardown_called = false
+          end
+          def setup
+            @setup_called = true
+          end
+          def teardown
+            @teardown_called = true
+          end
+          def test_succeed
+            assert_block {true}
+          end
+          def test_fail
+            assert_block {false}
+          end
+          def test_error
+            raise "Error!"
+          end
+        end
+        result = TestResult.new
+  
+        test = tc.new(:test_succeed)
+        test.run(result) {}
+        check("Should have called setup the correct number of times", test.setup_called)
+        check("Should have called teardown the correct number of times", test.teardown_called)
+  
+        test = tc.new(:test_fail)
+        test.run(result) {}
+        check("Should have called setup the correct number of times", test.setup_called)
+        check("Should have called teardown the correct number of times", test.teardown_called)
+  
+        test = tc.new(:test_error)
+        test.run(result) {}
+        check("Should have called setup the correct number of times", test.setup_called)
+        check("Should have called teardown the correct number of times", test.teardown_called)
+  
+        check("Should have had two test runs", result.run_count == 3)
+        check("Should have had a test failure", result.failure_count == 1)
+        check("Should have had a test error", result.error_count == 1)
+      end
+      
+      def test_assertion_failed_not_called
+        tc = Class.new(TestCase) do
+          def test_thing
+            raise AssertionFailedError.new
+          end
+        end
+        
+        suite = tc.suite
+        check("Should have one test", suite.size == 1)
+        result = TestResult.new
+        suite.run(result) {}
+        check("Should have had one test run", result.run_count == 1)
+        check("Should have had one assertion failure", result.failure_count == 1)
+        check("Should not have any assertion errors but had #{result.error_count}", result.error_count == 0)
+      end
+      
+      def test_equality
+        tc1 = Class.new(TestCase) do
+          def test_1
+          end
+          def test_2
+          end
+        end
+        
+        tc2 = Class.new(TestCase) do
+          def test_1
+          end
+        end
+      
+        test1 = tc1.new('test_1')
+        test2 = tc1.new('test_1')
+        check("Should be equal", test1 == test2)
+        check("Should be equal", test2 == test1)
+        
+        test1 = tc1.new('test_2')
+        check("Should not be equal", test1 != test2)
+        check("Should not be equal", test2 != test1)
+        
+        test2 = tc1.new('test_2')
+        check("Should be equal", test1 == test2)
+        check("Should be equal", test2 == test1)
+        
+        test1 = tc1.new('test_1')
+        test2 = tc2.new('test_1')
+        check("Should not be equal", test1 != test2)
+        check("Should not be equal", test2 != test1)
+
+        
+        check("Should not be equal", test1 != Object.new)
+        check("Should not be equal", Object.new != test1)
+      end
+      
+      def check(message, passed)
+        @_result.add_assertion
+        if ! passed
+          raise AssertionFailedError.new(message)
+        end
+      end
+    end
+  end
+end

data/test/test_testresult.rb

@@ -0,0 +1,104 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/testcase'
+require 'test/unit/testresult'
+
+module Test
+  module Unit
+    class TC_TestResult < TestCase
+      def setup
+        @my_result = TestResult.new
+        @my_result.add_assertion()
+        @my_result.add_failure("")
+        @my_result.add_error("")
+      end
+      def test_result_changed_notification
+        called1 = false
+        @my_result.add_listener( TestResult::CHANGED) {
+          |result|
+          assert_block("The result should be correct") { result == @my_result }
+          called1 = true
+        }
+        @my_result.add_assertion
+        assert_block("Should have been notified when the assertion happened") { called1 }
+        
+        called1, called2 = false, false
+        @my_result.add_listener( TestResult::CHANGED) {
+          |result|
+          assert_block("The result should be correct") { result == @my_result }
+          called2 = true
+        }
+        @my_result.add_assertion
+        assert_block("Both listeners should have been notified for a success") { called1 && called2 }
+  
+        called1, called2 = false, false
+        @my_result.add_failure("")
+        assert_block("Both listeners should have been notified for a failure") { called1 && called2 }
+  
+        called1, called2 = false, false    
+        @my_result.add_error("")
+        assert_block("Both listeners should have been notified for an error") { called1 && called2 }
+  
+        called1, called2 = false, false    
+        @my_result.add_run
+        assert_block("Both listeners should have been notified for a run") { called1 && called2 }
+      end
+      def test_fault_notification
+        called1 = false
+        fault = "fault"
+        @my_result.add_listener(TestResult::FAULT) {
+          | passed_fault |
+          assert_block("The fault should be correct") { passed_fault == fault }
+          called1 = true
+        }
+  
+        @my_result.add_assertion
+        assert_block("Should not have been notified when the assertion happened") { !called1 }
+        
+        @my_result.add_failure(fault)
+        assert_block("Should have been notified when the failure happened") { called1 }
+        
+        called1, called2 = false, false
+        @my_result.add_listener(TestResult::FAULT) {
+          | passed_fault |
+          assert_block("The fault should be correct") { passed_fault == fault }
+          called2 = true
+        }
+  
+        @my_result.add_assertion
+        assert_block("Neither listener should have been notified for a success") { !(called1 || called2) }
+  
+        called1, called2 = false, false
+        @my_result.add_failure(fault)
+        assert_block("Both listeners should have been notified for a failure") { called1 && called2 }
+  
+        called1, called2 = false, false    
+        @my_result.add_error(fault)
+        assert_block("Both listeners should have been notified for an error") { called1 && called2 }
+  
+        called1, called2 = false, false
+        @my_result.add_run
+        assert_block("Neither listener should have been notified for a run") { !(called1 || called2) }
+      end
+      def test_passed?
+        result = TestResult.new
+        assert(result.passed?, "An empty result should have passed")
+  
+        result.add_assertion
+        assert(result.passed?, "Adding an assertion should not cause the result to not pass")
+  
+        result.add_run
+        assert(result.passed?, "Adding a run should not cause the result to not pass")
+  
+        result.add_failure("")
+        assert(!result.passed?, "Adding a failed assertion should cause the result to not pass")
+  
+        result = TestResult.new
+        result.add_error("")
+        assert(!result.passed?, "Adding an error should cause the result to not pass")
+      end
+    end
+  end
+end

data/test/test_testsuite.rb

@@ -0,0 +1,129 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit'
+
+module Test
+  module Unit
+    class TC_TestSuite < TestCase
+      def setup
+        @testcase1 = Class.new(TestCase) do
+          def test_succeed1
+            assert_block { true }
+          end
+          def test_fail
+            assert_block { false }
+          end
+        end
+
+        @testcase2 = Class.new(TestCase) do
+          def test_succeed2
+            assert_block { true }
+          end
+          def test_error
+            raise
+          end
+        end
+      end
+
+      def test_add
+        s = TestSuite.new
+        assert_equal(s, s << self.class.new("test_add"))
+      end
+
+      def test_delete
+        s = TestSuite.new
+        t1 = self.class.new("test_delete")
+        s << t1
+        t2 = self.class.new("test_add")
+        s << t2
+        assert_equal(t1, s.delete(t1))
+        assert_nil(s.delete(t1))
+        assert_equal(TestSuite.new << t2, s)
+      end
+
+      def test_size
+        suite = TestSuite.new
+        suite2 = TestSuite.new
+        suite2 << self.class.new("test_size")
+        suite << suite2
+        suite << self.class.new("test_size")
+        assert_equal(2, suite.size, "The count should be correct")
+      end
+      
+      def test_run
+        progress = []
+        suite = @testcase1.suite
+        result = TestResult.new
+        suite.run(result) { |*values| progress << values }
+  
+        assert_equal(2, result.run_count, "Should have had four test runs")
+        assert_equal(1, result.failure_count, "Should have had one test failure")
+        assert_equal(0, result.error_count, "Should have had one test error")
+        assert_equal([[TestSuite::STARTED, suite.name],
+                [TestCase::STARTED, "test_fail(#{suite.name})"],
+                [TestCase::FINISHED, "test_fail(#{suite.name})"],
+                [TestCase::STARTED, "test_succeed1(#{suite.name})"],
+                [TestCase::FINISHED, "test_succeed1(#{suite.name})"],
+                [TestSuite::FINISHED, suite.name]],
+                progress, "Should have had the correct progress")
+        
+        suite = TestSuite.new
+        suite << @testcase1.suite
+        suite << @testcase2.suite
+        result = TestResult.new
+        progress = []
+        suite.run(result) { |*values| progress << values }
+  
+        assert_equal(4, result.run_count, "Should have had four test runs")
+        assert_equal(1, result.failure_count, "Should have had one test failure")
+        assert_equal(1, result.error_count, "Should have had one test error")
+        assert_equal(14, progress.size, "Should have had the correct number of progress calls")
+      end
+      
+      def test_empty?
+        assert(TestSuite.new.empty?, "A new test suite should be empty?")
+        assert(!@testcase2.suite.empty?, "A test suite with tests should not be empty")
+      end
+      
+      def test_equality
+        suite1 = TestSuite.new
+        suite2 = TestSuite.new
+        assert_equal(suite1, suite2)
+        assert_equal(suite2, suite1)
+        
+        suite1 = TestSuite.new('name')
+        assert_not_equal(suite1, suite2)
+        assert_not_equal(suite2, suite1)
+        
+        suite2 = TestSuite.new('name')
+        assert_equal(suite1, suite2)
+        assert_equal(suite2, suite1)
+        
+        suite1 << 'test'
+        assert_not_equal(suite1, suite2)
+        assert_not_equal(suite2, suite1)
+        
+        suite2 << 'test'
+        assert_equal(suite1, suite2)
+        assert_equal(suite2, suite1)
+        
+        suite2 = Object.new
+        class << suite2
+          def name
+            'name'
+          end
+          def tests
+            ['test']
+          end
+        end
+        assert_not_equal(suite1, suite2)
+        assert_not_equal(suite2, suite1)
+
+        assert_not_equal(suite1, Object.new)
+        assert_not_equal(Object.new, suite1)
+      end
+    end
+  end
+end