glib2 0.20.0 → 0.90.2

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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,287 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,81 @@
+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