cairo 1.6.1-x86-mswin32 → 1.7.0-x86-mswin32

data/test-unit/lib/test/unit/runner/console.rb

@@ -0,0 +1,46 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:console) do |auto_runner|
+      require 'test/unit/ui/console/testrunner'
+      Test::Unit::UI::Console::TestRunner
+    end
+
+    AutoRunner.setup_option do |auto_runner, opts|
+      require 'test/unit/ui/console/outputlevel'
+
+      output_levels = [
+        [:silent, UI::Console::OutputLevel::SILENT],
+        [:progress, UI::Console::OutputLevel::PROGRESS_ONLY],
+        [:normal, UI::Console::OutputLevel::NORMAL],
+        [:verbose, UI::Console::OutputLevel::VERBOSE],
+      ]
+      opts.on('-v', '--verbose=[LEVEL]', output_levels,
+              "Set the output level (default is verbose).",
+              "(#{auto_runner.keyword_display(output_levels)})") do |level|
+        level ||= output_levels.assoc(:verbose)[1]
+        auto_runner.runner_options[:output_level] = level
+      end
+
+      use_color_options = [
+        [:auto, :auto],
+        ["-", false],
+        ["no", false],
+        ["false", false],
+        ["+", true],
+        ["yes", true],
+        ["true", true],
+      ]
+      opts.on("--[no-]use-color=[auto]", use_color_options,
+              "Use color output",
+              "(default is auto") do |use_color|
+        case use_color
+        when nil
+          use_color = true
+        when :auto
+          use_color = nil
+        end
+        auto_runner.runner_options[:use_color] = use_color
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Test
+  module Unit
+    AutoRunner.register_runner(:emacs) do |auto_runner|
+      require 'test/unit/ui/emacs/testrunner'
+      Test::Unit::UI::Emacs::TestRunner
+    end
+  end
+end

data/test-unit/lib/test/unit/testcase.rb

@@ -0,0 +1,281 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/attribute'
+require 'test/unit/fixture'
+require 'test/unit/exceptionhandler'
+require 'test/unit/assertions'
+require 'test/unit/failure'
+require 'test/unit/error'
+require 'test/unit/pending'
+require 'test/unit/omission'
+require 'test/unit/notification'
+require 'test/unit/priority'
+require 'test/unit/testsuite'
+require 'test/unit/assertionfailederror'
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+
+    # Ties everything together. If you subclass and add your own
+    # test methods, it takes care of making them into tests and
+    # wrapping those tests into a suite. It also does the
+    # nitty-gritty of actually running an individual test and
+    # collecting its results into a Test::Unit::TestResult object.
+    #
+    # You can run two hooks before/after a TestCase run.
+    #
+    # Example:
+    #   class TestMyClass < Test::Unit::TestCase
+    #     class << self
+    #       def startup
+    #         ...
+    #       end
+    #
+    #       def shutdown
+    #         ...
+    #       end
+    #     end
+    #
+    #     def setup
+    #       ...
+    #     end
+    #
+    #     def teardown
+    #       ...
+    #     end
+    #
+    #     def test_my_method1
+    #       ...
+    #     end
+    #
+    #     def test_my_method2
+    #       ...
+    #     end
+    #   end
+    #
+    # Here is a call order:
+    #  * startup
+    #  * setup
+    #  * test_my_method1
+    #  * teardown
+    #  * setup
+    #  * test_my_method2
+    #  * teardown
+    #  * shutdown
+    class TestCase
+      include Attribute
+      include Fixture
+      include ExceptionHandler
+      include ErrorHandler
+      include FailureHandler
+      include TestCasePendingSupport
+      include TestCaseOmissionSupport
+      include TestCaseNotificationSupport
+      include Priority
+      include Assertions
+      include Util::BacktraceFilter
+
+      STARTED = name + "::STARTED"
+      FINISHED = name + "::FINISHED"
+
+      DESCENDANTS = []
+
+      class << self
+        def inherited(sub_class)
+          DESCENDANTS << sub_class
+        end
+
+        # Rolls up all of the test* methods in the fixture into
+        # one suite, creating a new instance of the fixture for
+        # each method.
+        def suite
+          method_names = public_instance_methods(true).collect {|name| name.to_s}
+          tests = method_names.delete_if {|method_name| method_name !~ /^test./}
+          suite = TestSuite.new(name, self)
+          tests.sort.each do |test|
+            catch(:invalid_test) do
+              suite << new(test)
+            end
+          end
+          if suite.empty?
+            catch(:invalid_test) do
+              suite << new("default_test")
+            end
+          end
+          suite
+        end
+      end
+
+      attr_reader :method_name
+
+      # Creates a new instance of the fixture for running the
+      # test represented by test_method_name.
+      def initialize(test_method_name)
+        throw :invalid_test unless respond_to?(test_method_name)
+        throw :invalid_test if method(test_method_name).arity > 0
+        @method_name = test_method_name
+        @test_passed = true
+        @interrupted = false
+      end
+
+      # Runs the individual test method represented by this
+      # instance of the fixture, collecting statistics, failures
+      # and errors in result.
+      def run(result)
+        begin
+          @_result = result
+          yield(STARTED, name)
+          begin
+            run_setup
+            run_test
+          rescue Exception
+            @interrupted = true
+            raise unless handle_exception($!)
+          ensure
+            begin
+              run_teardown
+            rescue Exception
+              raise unless handle_exception($!)
+            end
+          end
+          result.add_run
+          yield(FINISHED, name)
+        ensure
+          @_result = nil
+        end
+      end
+
+      # Called before every test method runs. Can be used
+      # to set up fixture information.
+      #
+      # You can add additional setup tasks by the following
+      # code:
+      #   class TestMyClass < Test::Unit::TestCase
+      #     def setup
+      #       ...
+      #     end
+      #
+      #     setup
+      #     def my_setup1
+      #       ...
+      #     end
+      #
+      #     setup
+      #     def my_setup2
+      #       ...
+      #     end
+      #
+      #     def test_my_class
+      #       ...
+      #     end
+      #   end
+      #
+      # Here is a call order:
+      #   * setup
+      #   * my_setup1
+      #   * my_setup2
+      #   * test_my_class
+      def setup
+      end
+
+      # Called after every test method runs. Can be used to tear
+      # down fixture information.
+      #
+      # You can add additional teardown tasks by the following
+      # code:
+      #   class TestMyClass < Test::Unit::TestCase
+      #     def teardown
+      #       ...
+      #     end
+      #
+      #     teardown
+      #     def my_teardown1
+      #       ...
+      #     end
+      #
+      #     teardown
+      #     def my_teardown2
+      #       ...
+      #     end
+      #
+      #     def test_my_class
+      #       ...
+      #     end
+      #   end
+      #
+      # Here is a call order:
+      #   * test_my_class
+      #   * my_teardown2
+      #   * my_teardown1
+      #   * teardown
+      def teardown
+      end
+      
+      def default_test
+        flunk("No tests were specified")
+      end
+
+      def size
+        1
+      end
+
+      # Returns a human-readable name for the specific test that
+      # this instance of TestCase represents.
+      def name
+        "#{@method_name}(#{self.class.name})"
+      end
+
+      # Overridden to return #name.
+      def to_s
+        name
+      end
+
+      # It's handy to be able to compare TestCase instances.
+      def ==(other)
+        return false unless(other.kind_of?(self.class))
+        return false unless(@method_name == other.method_name)
+        self.class == other.class
+      end
+
+      def interrupted?
+        @interrupted
+      end
+
+      private
+      def current_result
+        @_result
+      end
+
+      def run_test
+        __send__(@method_name)
+      end
+
+      def handle_exception(exception)
+        self.class.exception_handlers.each do |handler|
+          return true if send(handler, exception)
+        end
+        false
+      end
+
+      # Returns whether this individual test passed or
+      # not. Primarily for use in teardown so that artifacts
+      # can be left behind if the test fails.
+      def passed?
+        @test_passed
+      end
+
+      def problem_occurred
+        @test_passed = false
+      end
+
+      def add_assertion
+        current_result.add_assertion
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/testresult.rb

@@ -0,0 +1,89 @@
+#--
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/util/observable'
+require 'test/unit/failure'
+require 'test/unit/error'
+require 'test/unit/omission'
+require 'test/unit/pending'
+require 'test/unit/notification'
+
+module Test
+  module Unit
+    module NullResultContainerInitializer
+      private
+      def initialize_containers
+      end
+    end
+
+    # Collects Test::Unit::Failure and Test::Unit::Error so that
+    # they can be displayed to the user. To this end, observers
+    # can be added to it, allowing the dynamic updating of, say, a
+    # UI.
+    class TestResult
+      include Util::Observable
+      include NullResultContainerInitializer
+      include TestResultFailureSupport
+      include TestResultErrorSupport
+      include TestResultPendingSupport
+      include TestResultOmissionSupport
+      include TestResultNotificationSupport
+
+      CHANGED = "CHANGED"
+      FAULT = "FAULT"
+
+      attr_reader :run_count, :assertion_count, :faults
+
+      # Constructs a new, empty TestResult.
+      def initialize
+        @run_count, @assertion_count = 0, 0
+        @summary_generators = []
+        @problem_checkers = []
+        @faults = []
+        initialize_containers
+      end
+
+      # Records a test run.
+      def add_run
+        @run_count += 1
+        notify_changed
+      end
+
+      # Records an individual assertion.
+      def add_assertion
+        @assertion_count += 1
+        notify_changed
+      end
+
+      # Returns a string contain the recorded runs, assertions,
+      # failures and errors in this TestResult.
+      def summary
+        ["#{run_count} tests",
+         "#{assertion_count} assertions",
+         *@summary_generators.collect {|generator| send(generator)}].join(", ")
+      end
+
+      def to_s
+        summary
+      end
+
+      # Returns whether or not this TestResult represents
+      # successful completion.
+      def passed?
+        @problem_checkers.all? {|checker| not send(checker)}
+      end
+
+      private
+      def notify_changed
+        notify_listeners(CHANGED, self)
+      end
+
+      def notify_fault(fault)
+        @faults << fault
+        notify_listeners(FAULT, fault)
+      end
+    end
+  end
+end

data/test-unit/lib/test/unit/testsuite.rb

@@ -0,0 +1,110 @@
+#--
+#
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'test/unit/error'
+
+module Test
+  module Unit
+
+    # A collection of tests which can be #run.
+    #
+    # Note: It is easy to confuse a TestSuite instance with
+    # something that has a static suite method; I know because _I_
+    # have trouble keeping them straight. Think of something that
+    # has a suite method as simply providing a way to get a
+    # meaningful TestSuite instance.
+    class TestSuite
+      attr_reader :name, :tests
+      
+      STARTED = name + "::STARTED"
+      FINISHED = name + "::FINISHED"
+
+      # Creates a new TestSuite with the given name.
+      def initialize(name="Unnamed TestSuite", test_case=nil)
+        @name = name
+        @tests = []
+        @test_case = test_case
+      end
+
+      # Runs the tests and/or suites contained in this
+      # TestSuite.
+      def run(result, &progress_block)
+        yield(STARTED, name)
+        run_startup(result)
+        @tests.each do |test|
+          test.run(result, &progress_block)
+        end
+        run_shutdown(result)
+        yield(FINISHED, name)
+      end
+
+      # Adds the test to the suite.
+      def <<(test)
+        @tests << test
+        self
+      end
+
+      def delete(test)
+        @tests.delete(test)
+      end
+
+      # Retuns the rolled up number of tests in this suite;
+      # i.e. if the suite contains other suites, it counts the
+      # tests within those suites, not the suites themselves.
+      def size
+        total_size = 0
+        @tests.each { |test| total_size += test.size }
+        total_size
+      end
+      
+      def empty?
+        tests.empty?
+      end
+
+      # Overridden to return the name given the suite at
+      # creation.
+      def to_s
+        @name
+      end
+      
+      # It's handy to be able to compare TestSuite instances.
+      def ==(other)
+        return false unless(other.kind_of?(self.class))
+        return false unless(@name == other.name)
+        @tests == other.tests
+      end
+
+      private
+      def run_startup(result)
+        return if @test_case.nil? or !@test_case.respond_to?(:startup)
+        begin
+          @test_case.startup
+        rescue Exception
+          raise unless handle_exception($!, result)
+        end
+      end
+
+      def run_shutdown(result)
+        return if @test_case.nil? or !@test_case.respond_to?(:shutdown)
+        begin
+          @test_case.shutdown
+        rescue Exception
+          raise unless handle_exception($!, result)
+        end
+      end
+
+      def handle_exception(exception, result)
+        case exception
+        when *ErrorHandler::PASS_THROUGH_EXCEPTIONS
+          false
+        else
+          result.add_error(Error.new(@test_case.name, exception))
+          true
+        end
+      end
+    end
+  end
+end