rroonga 0.9.3 → 0.9.4

data/test-unit/test/test-emacs-runner.rb

@@ -1,60 +0,0 @@
-require 'test/unit'
-require 'test/unit/ui/emacs/testrunner'
-
-class TestUnitEmacsRunner < Test::Unit::TestCase
-  def test_format_failure_with_a_location
-    runner = create_runner
-    test_name = "test_failure"
-    file = "/home/user/test_xxx.rb"
-    line = "3"
-    info = "in `xxx'"
-    location = "#{file}:#{line}: #{info}"
-    message = "FAIL!!!"
-    failure = Test::Unit::Failure.new(test_name, [location], message)
-    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
-Failure:
-#{test_name} [#{file}:#{line}]:
-#{message}
-EOM
-  end
-
-  def test_format_failure_with_locations
-    runner = create_runner
-    test_name = "test_failure"
-    locations = ["/home/user/test_xxx.rb:3: in `xxx'",
-                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
-                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
-    message = "Many backtrace!!!"
-    failure = Test::Unit::Failure.new(test_name, locations, message)
-    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
-Failure:
-#{test_name}
-#{locations.join("\n")}:
-#{message}
-EOM
-  end
-
-  def test_format_error
-    runner = create_runner
-    test_name = "test_error"
-    message = "Error Message!!!"
-    backtrace = ["/home/user/test_xxx.rb:3: in `xxx'",
-                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
-                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
-    exception = RuntimeError.new(message)
-    exception.set_backtrace(backtrace)
-    error = Test::Unit::Error.new(test_name, exception)
-    assert_equal(<<-EOM.chomp, runner.send(:format_fault, error))
-Error:
-#{test_name}:
-#{exception.class.name}: #{message}
-#{backtrace.join("\n")}
-EOM
-  end
-
-  private
-  def create_runner(suite=nil)
-    suite ||= Test::Unit::TestSuite.new
-    Test::Unit::UI::Emacs::TestRunner.new(suite)
-  end
-end

data/test-unit/test/test-fixture.rb

@@ -1,287 +0,0 @@
-class TestUnitFixture < Test::Unit::TestCase
-  module EmptyModule
-  end
-
-  def test_setup_without_option
-    expected_setup_calls = [:setup,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :custom_setup_method3]
-    test_case = assert_setup(expected_setup_calls, [])
-    assert_inherited_setup(expected_setup_calls, test_case)
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
-
-  def test_setup_with_before_option
-    expected_setup_calls = [:custom_setup_method3,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :setup]
-    test_case = assert_setup(expected_setup_calls,
-                             [[{:before => :append}],
-                              [{:before => :append}],
-                              [{:before => :prepend}],
-                              [{:before => :prepend}]])
-    assert_inherited_setup(expected_setup_calls, test_case)
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
-
-  def test_setup_with_after_option
-    expected_setup_calls = [:setup,
-                            :custom_setup_method3,
-                            :custom_setup_method0,
-                            :custom_setup_method1]
-    test_case = assert_setup(expected_setup_calls,
-                             [[{:after => :append}],
-                              [{:after => :append}],
-                              [{:after => :prepend}],
-                              [{:after => :prepend}]])
-    assert_inherited_setup(expected_setup_calls, test_case)
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
-
-  def test_setup_with_invalid_option
-    assert_invalid_setup_option(:unknown => true)
-    assert_invalid_setup_option(:before => :unknown)
-    assert_invalid_setup_option(:after => :unknown)
-  end
-
-  def test_setup_with_option_to_inherited
-    expected_setup_calls = [:setup]
-    test_case = assert_setup(expected_setup_calls, nil)
-    assert_inherited_setup([:setup,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :custom_setup_method3],
-                           test_case,
-                           [])
-
-    assert_inherited_setup([:setup], nil)
-    assert_called_fixtures(expected_setup_calls, test_case)
-  end
-
-  def test_teardown_without_option
-    expected_teardown_calls = [:custom_teardown_method3,
-                               :custom_teardown_method1,
-                               :custom_teardown_method0,
-                               :teardown]
-    test_case = assert_teardown(expected_teardown_calls, [])
-    assert_inherited_teardown(expected_teardown_calls, test_case)
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
-
-  def test_teardown_with_before_option
-    expected_teardown_calls = [:custom_teardown_method3,
-                               :custom_teardown_method0,
-                               :custom_teardown_method1,
-                               :teardown]
-    test_case = assert_teardown(expected_teardown_calls,
-                                [[{:before => :append}],
-                                 [{:before => :append}],
-                                 [{:before => :prepend}],
-                                 [{:before => :prepend}]])
-    assert_inherited_teardown(expected_teardown_calls, test_case)
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
-
-  def test_teardown_with_after_option
-    expected_teardown_calls = [:teardown,
-                               :custom_teardown_method3,
-                               :custom_teardown_method0,
-                               :custom_teardown_method1]
-    test_case = assert_teardown(expected_teardown_calls,
-                                [[{:after => :append}],
-                                 [{:after => :append}],
-                                 [{:after => :prepend}],
-                                 [{:after => :prepend}]])
-    assert_inherited_teardown(expected_teardown_calls, test_case)
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
-
-  def test_teardown_with_invalid_option
-    assert_invalid_teardown_option(:unknown => true)
-    assert_invalid_teardown_option(:before => :unknown)
-    assert_invalid_teardown_option(:after => :unknown)
-  end
-
-  def test_teardown_with_option_to_inherited
-    expected_teardown_calls = [:teardown]
-    test_case = assert_teardown(expected_teardown_calls, nil)
-    assert_inherited_teardown([:custom_teardown_method3,
-                               :custom_teardown_method1,
-                               :custom_teardown_method0,
-                               :teardown],
-                              test_case, [])
-
-    assert_inherited_teardown([:teardown], nil)
-    assert_called_fixtures(expected_teardown_calls, test_case)
-  end
-
-  private
-  def assert_called_fixtures(expected, test_case)
-    test = test_case.new("test_nothing")
-    test.run(Test::Unit::TestResult.new) {}
-    assert_equal(expected, test.called_ids)
-  end
-
-  def assert_setup_customizable(expected, parent, options)
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
-
-      def called_ids
-        @called_ids ||= []
-      end
-
-      def called(id)
-        called_ids << id
-      end
-
-      def setup
-        called(:setup)
-      end
-
-      setup(*(options[0] || [])) if options
-      def custom_setup_method0
-        called(:custom_setup_method0)
-      end
-
-      def custom_setup_method1
-        called(:custom_setup_method1)
-      end
-      setup(*[:custom_setup_method1, *(options[1] || [])]) if options
-
-      setup(*(options[2] || [])) if options
-      def custom_setup_method2
-        called(:custom_setup_method2)
-      end
-      unregister_setup(:custom_setup_method2) if options
-
-      setup(*(options[3] || [])) if options
-      def custom_setup_method3
-        called(:custom_setup_method3)
-      end
-
-      def test_nothing
-      end
-
-      yield(self, :after) if block_given?
-    end
-
-    assert_called_fixtures(expected, test_case)
-    test_case
-  end
-
-  def assert_setup(expected, options)
-    _test_case = assert_setup_customizable(expected, nil, options)
-    assert_setup_customizable(expected, nil, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-    _test_case
-  end
-
-  def assert_inherited_setup(expected, parent, options=nil)
-    _test_case = assert_setup_customizable(expected, parent, options)
-    assert_setup_customizable(expected, parent, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-    _test_case
-  end
-
-  def assert_teardown_customizable(expected, parent, options)
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
-
-      def called_ids
-        @called_ids ||= []
-      end
-
-      def called(id)
-        called_ids << id
-      end
-
-      def teardown
-        called(:teardown)
-      end
-
-      teardown(*(options[0] || [])) if options
-      def custom_teardown_method0
-        called(:custom_teardown_method0)
-      end
-
-      def custom_teardown_method1
-        called(:custom_teardown_method1)
-      end
-      teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options
-
-      teardown(*(options[2] || [])) if options
-      def custom_teardown_method2
-        called(:custom_teardown_method2)
-      end
-      unregister_teardown(:custom_teardown_method2) if options
-
-      teardown(*(options[3] || [])) if options
-      def custom_teardown_method3
-        called(:custom_teardown_method3)
-      end
-
-      def test_nothing
-      end
-
-      yield(self, :after) if block_given?
-    end
-
-    assert_called_fixtures(expected, test_case)
-    test_case
-  end
-
-  def assert_teardown(expected, options)
-    assert_teardown_customizable(expected, nil, options)
-    assert_teardown_customizable(expected, nil, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-  end
-
-  def assert_inherited_teardown(expected, parent, options=nil)
-    assert_teardown_customizable(expected, parent, options)
-    assert_teardown_customizable(expected, parent, options) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-  end
-
-  def assert_invalid_option(fixture_type, option)
-    exception = assert_raise(ArgumentError) do
-      Class.new(Test::Unit::TestCase) do
-        def test_nothing
-        end
-
-        send(fixture_type, option)
-        def fixture
-        end
-      end
-    end
-    assert_equal("must be {:before => :prepend}, {:before => :append}, " +
-                 "{:after => :prepend} or {:after => :append}" +
-                 ": #{option.inspect}",
-                 exception.message)
-  end
-
-  def assert_invalid_setup_option(option)
-    assert_invalid_option(:setup, option)
-  end
-
-  def assert_invalid_teardown_option(option)
-    assert_invalid_option(:teardown, option)
-  end
-end

data/test-unit/test/test-notification.rb

@@ -1,33 +0,0 @@
-require 'test/unit'
-require 'testunit-test-util'
-
-class TestUnitNotification < Test::Unit::TestCase
-  include TestUnitTestUtil
-
-  class TestCase < Test::Unit::TestCase
-    class << self
-      def suite
-        Test::Unit::TestSuite.new(name)
-      end
-    end
-
-    def test_notify
-      notify("1st notify")
-      notify("2nd notify. Reach here.")
-    end
-  end
-
-  def test_notify
-    result = _run_test("test_notify")
-    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "0 omissions, 2 notifications",
-                 result.to_s)
-    assert_fault_messages(["1st notify", "2nd notify. Reach here."],
-                          result.notifications)
-  end
-
-  private
-  def _run_test(name)
-    super(TestCase, name)
-  end
-end

data/test-unit/test/test-omission.rb

@@ -1,81 +0,0 @@
-require 'test/unit'
-require 'testunit-test-util'
-
-class TestUnitOmission < Test::Unit::TestCase
-  include TestUnitTestUtil
-
-  class TestCase < Test::Unit::TestCase
-    class << self
-      def suite
-        Test::Unit::TestSuite.new(name)
-      end
-    end
-
-    def test_omit
-      omit("1st omit")
-      omit("2nd omit. Should not be reached here.")
-      assert(true, "Should not be reached here too.")
-    end
-
-    def test_omit_with_condition
-      omit_if(false, "Never omit.")
-      omit_unless(true, "Never omit too.")
-      omit_if(true, "Should omit.")
-      omit("The last omit. Should not be reached here.")
-    end
-
-    def test_omit_with_block
-      omit("Omit block") do
-        flunk("Should not be reached here.")
-      end
-      assert(true, "Should be reached here.")
-    end
-
-    def test_omit_with_block_and_condition
-      omit_if(false, "Never omit.") do
-        assert(true, "Should be reached here.")
-      end
-      omit_if(true, "Should omit.") do
-        flunk("Never reached here.")
-      end
-      assert(true, "Should be reached here too.")
-    end
-  end
-
-  def test_omit
-    result = _run_test("test_omit")
-    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "1 omissions, 0 notifications",
-                 result.to_s)
-    assert_fault_messages(["1st omit"], result.omissions)
-  end
-
-  def test_omit_with_condition
-    result = _run_test("test_omit_with_condition")
-    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "1 omissions, 0 notifications",
-                 result.to_s)
-    assert_fault_messages(["Should omit."], result.omissions)
-  end
-
-  def test_omit_with_block
-    result = _run_test("test_omit_with_block")
-    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "1 omissions, 0 notifications",
-                 result.to_s)
-    assert_fault_messages(["Omit block"], result.omissions)
-  end
-
-  def test_omit_with_condition_and_block
-    result = _run_test("test_omit_with_block_and_condition")
-    assert_equal("1 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
-                 "1 omissions, 0 notifications",
-                 result.to_s)
-    assert_fault_messages(["Should omit."], result.omissions)
-  end
-
-  private
-  def _run_test(name)
-    super(TestCase, name)
-  end
-end