cairo 1.8.5-x86-mingw32 → 1.10.0-x86-mingw32

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_error.rb

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

@@ -1,33 +0,0 @@
-# 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_fixture.rb

@@ -1,252 +0,0 @@
-class TestUnitFixture < Test::Unit::TestCase
-  module EmptyModule
-  end
-
-  def test_setup_without_option
-    test_case = assert_setup([:setup,
-                              :custom_setup_method0,
-                              :custom_setup_method1,
-                              :custom_setup_method3],
-                             [])
-    assert_inherited_setup([:setup,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :custom_setup_method3],
-                           test_case)
-    assert_inherited_setup([:setup], nil)
-  end
-
-  def test_setup_with_before_option
-    test_case = assert_setup([:custom_setup_method3,
-                              :custom_setup_method0,
-                              :custom_setup_method1,
-                              :setup],
-                             [[{:before => :append}],
-                              [{:before => :append}],
-                              [{:before => :prepend}],
-                              [{:before => :prepend}]])
-    assert_inherited_setup([:custom_setup_method3,
-                            :custom_setup_method0,
-                            :custom_setup_method1,
-                            :setup],
-                           test_case)
-    assert_inherited_setup([:setup], nil)
-  end
-
-  def test_setup_with_after_option
-    test_case = assert_setup([:setup,
-                              :custom_setup_method3,
-                              :custom_setup_method0,
-                              :custom_setup_method1],
-                             [[{:after => :append}],
-                              [{:after => :append}],
-                              [{:after => :prepend}],
-                              [{:after => :prepend}]])
-    assert_inherited_setup([:setup,
-                            :custom_setup_method3,
-                            :custom_setup_method0,
-                            :custom_setup_method1],
-                           test_case)
-    assert_inherited_setup([:setup], nil)
-  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_teardown_without_option
-    test_case = assert_teardown([:custom_teardown_method3,
-                                 :custom_teardown_method1,
-                                 :custom_teardown_method0,
-                                 :teardown],
-                                [])
-    assert_inherited_teardown([:custom_teardown_method3,
-                               :custom_teardown_method1,
-                               :custom_teardown_method0,
-                               :teardown],
-                              test_case)
-    assert_inherited_teardown([:teardown], nil)
-  end
-
-  def test_teardown_with_before_option
-    test_case = assert_teardown([:custom_teardown_method3,
-                                 :custom_teardown_method0,
-                                 :custom_teardown_method1,
-                                 :teardown],
-                                [[{:before => :append}],
-                                 [{:before => :append}],
-                                 [{:before => :prepend}],
-                                 [{:before => :prepend}]])
-    assert_inherited_teardown([:custom_teardown_method3,
-                               :custom_teardown_method0,
-                               :custom_teardown_method1,
-                               :teardown],
-                              test_case)
-    assert_inherited_teardown([:teardown], nil)
-  end
-
-  def test_teardown_with_after_option
-    test_case = assert_teardown([:teardown,
-                                 :custom_teardown_method3,
-                                 :custom_teardown_method0,
-                                 :custom_teardown_method1],
-                                [[{:after => :append}],
-                                 [{:after => :append}],
-                                 [{:after => :prepend}],
-                                 [{:after => :prepend}]])
-    assert_inherited_teardown([:teardown,
-                               :custom_teardown_method3,
-                               :custom_teardown_method0,
-                               :custom_teardown_method1],
-                              test_case)
-    assert_inherited_teardown([:teardown], nil)
-  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
-
-  private
-  def assert_setup_customizable(expected, parent, options)
-    called = []
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
-
-      @@called = called
-      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
-
-    test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
-    assert_equal(expected, called)
-    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)
-    _test_case = assert_setup_customizable(expected, parent, nil)
-    assert_setup_customizable(expected, parent, nil) do |test_case, tag|
-      test_case.send(:include, EmptyModule) if tag == :before
-    end
-    _test_case
-  end
-
-  def assert_teardown_customizable(expected, parent, options)
-    called = []
-    test_case = Class.new(parent || Test::Unit::TestCase) do
-      yield(self, :before) if block_given?
-
-      @@called = called
-      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
-
-    test_case.new("test_nothing").run(Test::Unit::TestResult.new) {}
-    assert_equal(expected, called)
-    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)
-    assert_teardown_customizable(expected, parent, nil)
-    assert_teardown_customizable(expected, parent, nil) 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 TestNotification < 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, 1 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