rroonga 0.9.4-x86-mingw32 → 0.9.5-x86-mingw32

data/test-unit/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-unit/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-unit/test/test_testresult.rb

@@ -0,0 +1,113 @@
+# 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()
+        @failure = "failure"
+        @my_result.add_failure(@failure)
+        @error = "error"
+        @my_result.add_error(@error)
+      end
+
+      def test_result_changed_notification
+        called1 = false
+        @my_result.add_listener(TestResult::CHANGED) do |result|
+          assert_equal(@my_result, result)
+          called1 = true
+        end
+        @my_result.add_assertion
+        assert_true(called1)
+
+        called1, called2 = false, false
+        @my_result.add_listener(TestResult::CHANGED) do |result|
+          assert_equal(@my_result, result)
+          called2 = true
+        end
+        @my_result.add_assertion
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
+        @my_result.add_failure("")
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
+        @my_result.add_error("")
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
+        @my_result.add_run
+        assert_equal([true, true], [called1, called2])
+      end
+
+      def test_fault_notification
+        called1 = false
+        fault = "fault"
+        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
+          assert_equal(fault, passed_fault)
+          called1 = true
+        end
+
+        @my_result.add_assertion
+        assert_false(called1)
+
+        @my_result.add_failure(fault)
+        assert_true(called1)
+
+        called1, called2 = false, false
+        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
+          assert_equal(fault, passed_fault)
+          called2 = true
+        end
+
+        @my_result.add_assertion
+        assert_equal([false, false], [called1, called2])
+
+        called1, called2 = false, false
+        @my_result.add_failure(fault)
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
+        @my_result.add_error(fault)
+        assert_equal([true, true], [called1, called2])
+
+        called1, called2 = false, false
+        @my_result.add_run
+        assert_equal([false, false], [called1, called2])
+      end
+
+      def test_passed?
+        result = TestResult.new
+        assert_true(result.passed?)
+
+        result.add_assertion
+        assert_true(result.passed?)
+
+        result.add_run
+        assert_true(result.passed?)
+
+        result.add_failure("")
+        assert_false(result.passed?)
+
+        result = TestResult.new
+        result.add_error("")
+        assert_false(result.passed?)
+      end
+
+      def test_faults
+        assert_equal([@failure, @error], @my_result.faults)
+
+        notification = "notification"
+        @my_result.add_notification(notification)
+        assert_equal([@failure, @error, notification], @my_result.faults)
+      end
+    end
+  end
+end

data/test-unit/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

data/test-unit/test/testunit-test-util.rb

@@ -0,0 +1,14 @@
+module TestUnitTestUtil
+  private
+  def assert_fault_messages(expected, faults)
+    assert_equal(expected, faults.collect {|fault| fault.message})
+  end
+
+  def _run_test(test_case, name)
+    result = Test::Unit::TestResult.new
+    test = test_case.new(name)
+    yield(test) if block_given?
+    test.run(result) {}
+    result
+  end
+end

data/test-unit/test/ui/test_testrunmediator.rb

@@ -0,0 +1,20 @@
+require 'test/unit/ui/testrunnermediator'
+
+class TestUnitUIMediator < Test::Unit::TestCase
+  def test_run_suite_with_interrupt_exception
+    test_case = Class.new(Test::Unit::TestCase) do
+      def test_raise_interrupt
+        raise Interrupt, "from test"
+      end
+    end
+    mediator = Test::Unit::UI::TestRunnerMediator.new(test_case.suite)
+    finished = false
+    mediator.add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED) do
+      finished = true
+    end
+    assert_raise(Interrupt) do
+      mediator.run_suite
+    end
+    assert(finished)
+  end
+end

data/test-unit/test/util/test-method-owner-finder.rb

@@ -0,0 +1,38 @@
+require 'test/unit'
+
+require 'test/unit/util/method-owner-finder'
+
+class TestUnitMethodOwnerFinder < Test::Unit::TestCase
+  def test_find
+    assert_equal(Exception, find(RuntimeError.new, :inspect))
+    assert_equal(Exception, find(Exception.new, :inspect))
+
+    anonymous_class = Class.new do
+    end
+    assert_equal(Kernel, find(anonymous_class.new, :inspect))
+
+    anonymous_parent_class = Class.new do
+      def inspect
+        super + " by anonymous parent class"
+      end
+    end
+    anonymous_sub_class = Class.new(anonymous_parent_class) do
+    end
+    assert_equal(anonymous_parent_class, find(anonymous_sub_class.new, :inspect))
+
+    anonymous_module = Module.new do
+      def inspect
+        super + " by anonymous module"
+      end
+    end
+    anonymous_include_class = Class.new do
+      include anonymous_module
+    end
+    assert_equal(anonymous_module, find(anonymous_include_class.new, :inspect))
+  end
+
+  private
+  def find(object, method_name)
+    Test::Unit::Util::MethodOwnerFinder.find(object, method_name)
+  end
+end

data/test-unit/test/util/test_backtracefilter.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+
+require 'test/unit/util/backtracefilter'
+
+module Test::Unit::Util
+  class TestBacktraceFilter < Test::Unit::TestCase
+    include BacktraceFilter
+    
+    def test_filter_backtrace
+      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
+        %q{tc_thing.rb:4:in 'a'},
+        %q{tc_thing.rb:4:in 'test_stuff'},
+        %q{C:\some\old\path/test/unit/testcase.rb:44:in 'send'},
+        %q{C:\some\old\path\test\unit\testcase.rb:44:in 'run'},
+        %q{C:\some\old\path\test\unit.rb:44:in 'run'},
+        %q{tc_thing.rb:3}]
+      assert_equal(backtrace[1..2], filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
+
+backtrace = [%q{tc_thing.rb:4:in 'a'},
+        %q{tc_thing.rb:4:in 'test_stuff'},
+        %q{tc_thing.rb:3}]
+      assert_equal(backtrace, filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Shouldn't filter too much")
+
+      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
+        %q{tc_thing.rb:4:in 'a'},
+        %q{tc_thing.rb:4:in 'test_stuff'},
+        %q{tc_thing.rb:3}]
+      assert_equal(backtrace[1..3], filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
+      
+      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
+        %q{C:\some\old\path/test/unit/testcase.rb:44:in 'send'},
+        %q{C:\some\old\path\test\unit\testcase.rb:44:in 'run'},
+        %q{C:\some\old\path\test\unit.rb:44:in 'run'}]
+      assert_equal(backtrace, filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
+    end
+
+    def test_nil_backtrace
+      assert_equal(["No backtrace"], filter_backtrace(nil))
+    end
+  end
+end

data/test-unit/test/util/test_observable.rb

@@ -0,0 +1,102 @@
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/util/observable'
+
+module Test
+  module Unit
+    module Util
+      class TC_Observable < TestCase
+      
+        class TF_Observable
+          include Observable
+        end
+        
+        def setup
+          @observable = TF_Observable.new
+        end
+        
+        def test_simple_observation
+          assert_raises(ArgumentError, "add_listener should throw an exception if no callback is supplied") do
+            @observable.add_listener(:property, "a")
+          end
+      
+          heard = false
+          callback = proc { heard = true }
+          assert_equal("a", @observable.add_listener(:property, "a", &callback), "add_listener should return the listener that was added")
+      
+          count = 0
+          @observable.instance_eval do
+            count = notify_listeners(:property)
+          end
+          assert_equal(1, count, "notify_listeners should have returned the number of listeners that were notified")
+          assert(heard, "Should have heard the property changed")
+      
+          heard = false
+          assert_equal(callback, @observable.remove_listener(:property, "a"), "remove_listener should return the callback")
+          
+          count = 1
+          @observable.instance_eval do
+            count = notify_listeners(:property)
+          end
+          assert_equal(0, count, "notify_listeners should have returned the number of listeners that were notified")
+          assert(!heard, "Should not have heard the property change")
+        end
+        
+        def test_value_observation
+          value = nil
+          @observable.add_listener(:property, "a") do |passed_value|
+            value = passed_value
+          end
+          count = 0
+          @observable.instance_eval do
+            count = notify_listeners(:property, "stuff")
+          end
+          assert_equal(1, count, "Should have update the correct number of listeners")
+          assert_equal("stuff", value, "Should have received the value as an argument to the listener")
+        end
+        
+        def test_multiple_value_observation
+          values = []
+          @observable.add_listener(:property, "a") do |first_value, second_value|
+            values = [first_value, second_value]
+          end
+          count = 0
+          @observable.instance_eval do
+            count = notify_listeners(:property, "stuff", "more stuff")
+          end
+          assert_equal(1, count, "Should have update the correct number of listeners")
+          assert_equal(["stuff", "more stuff"], values, "Should have received the value as an argument to the listener")
+        end
+        
+        def test_add_remove_with_default_listener
+          assert_raises(ArgumentError, "add_listener should throw an exception if no callback is supplied") do
+            @observable.add_listener(:property)
+          end
+      
+          heard = false
+          callback = proc { heard = true }
+          assert_equal(callback, @observable.add_listener(:property, &callback), "add_listener should return the listener that was added")
+      
+          count = 0
+          @observable.instance_eval do
+            count = notify_listeners(:property)
+          end
+          assert_equal(1, count, "notify_listeners should have returned the number of listeners that were notified")
+          assert(heard, "Should have heard the property changed")
+      
+          heard = false
+          assert_equal(callback, @observable.remove_listener(:property, callback), "remove_listener should return the callback")
+      
+          count = 1
+          @observable.instance_eval do
+            count = notify_listeners(:property)
+          end
+          assert_equal(0, count, "notify_listeners should have returned the number of listeners that were notified")
+          assert(!heard, "Should not have heard the property change")
+        end
+      end
+    end
+  end
+end