glib2 0.90.8-x86-mingw32 → 0.90.9-x86-mingw32

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

@@ -1,180 +0,0 @@
-module Test
-  module Unit
-    module Priority
-      class << self
-        def included(base)
-          base.extend(ClassMethods)
-
-          base.class_eval do
-            setup :priority_setup, :before => :prepend
-            teardown :priority_teardown, :after => :append
-          end
-        end
-
-        @@enabled = false
-        def enabled?
-          @@enabled
-        end
-
-        def enable
-          require "fileutils"
-          require "tmpdir"
-          @@enabled = true
-        end
-
-        def disable
-          @@enabled = false
-        end
-
-        @@default = :normal
-        def default
-          @@default || :normal
-        end
-
-        def default=(default)
-          @@default = default
-        end
-
-        def available_values
-          Checker.available_priorities
-        end
-      end
-
-      class Checker
-        class << self
-          def have_priority?(name)
-            singleton_class = (class << self; self; end)
-            singleton_class.method_defined?(priority_check_method_name(name))
-          end
-
-          def need_to_run?(test)
-            priority = test[:priority] || Priority.default
-            if have_priority?(priority)
-              send(priority_check_method_name(priority), test)
-            else
-              true
-            end
-          end
-
-          def available_priorities
-            methods(false).collect do |name|
-              /\Arun_priority_(.+)\?\z/ =~ name.to_s
-              $1
-            end.compact
-          end
-
-          def run_priority_must?(test)
-            true
-          end
-
-          def run_priority_important?(test)
-            rand > 0.1
-          end
-
-          def run_priority_high?(test)
-            rand > 0.3
-          end
-
-          def run_priority_normal?(test)
-            rand > 0.5
-          end
-
-          def run_priority_low?(test)
-            rand > 0.75
-          end
-
-          def run_priority_never?(test)
-            false
-          end
-
-          private
-          def priority_check_method_name(priority_name)
-            "run_priority_#{priority_name}?"
-          end
-        end
-
-        attr_reader :test
-        def initialize(test)
-          @test = test
-        end
-
-        def setup
-          FileUtils.rm_f(passed_file)
-        end
-
-        def teardown
-          if @test.send(:passed?)
-            FileUtils.touch(passed_file)
-          else
-            FileUtils.rm_f(passed_file)
-          end
-        end
-
-        def need_to_run?
-          !previous_test_success? or self.class.need_to_run?(@test)
-        end
-
-        private
-        def previous_test_success?
-          File.exist?(passed_file)
-        end
-
-        def result_dir
-          components = [".test-result",
-                        @test.class.name || "AnonymousTestCase",
-                        escaped_method_name]
-          parent_directories = [File.dirname($0), Dir.pwd]
-          if Process.respond_to?(:uid)
-            parent_directories << File.join(Dir.tmpdir, Process.uid.to_s)
-          end
-          parent_directories.each do |parent_directory|
-            dir = File.expand_path(File.join(parent_directory, *components))
-            begin
-              FileUtils.mkdir_p(dir)
-              return dir
-            rescue Errno::EACCES
-            end
-          end
-
-          raise Errno::EACCES, parent_directories.join(", ")
-        end
-
-        def passed_file
-          File.join(result_dir, "passed")
-        end
-
-        def escaped_method_name
-          @test.method_name.to_s.gsub(/[!?=]$/) do |matched|
-            case matched
-            when "!"
-              ".destructive"
-            when "?"
-              ".predicate"
-            when "="
-              ".equal"
-            end
-          end
-        end
-      end
-
-      module ClassMethods
-        def priority(name, *tests)
-          unless Checker.have_priority?(name)
-            raise ArgumentError, "unknown priority: #{name}"
-          end
-          attribute(:priority, name, {:keep => true}, *tests)
-        end
-      end
-
-      def priority_setup
-        return unless Priority.enabled?
-        Checker.new(self).setup
-      end
-
-      def priority_teardown
-        return unless Priority.enabled?
-        Checker.new(self).teardown
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-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,
-              "Uses 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
-
-      opts.on("--progress-row-max=MAX", Integer,
-              "Uses MAX as max terminal width for progress mark",
-              "(default is auto)") do |max|
-        auto_runner.runner_options[:progress_row_max] = max
-      end
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-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/runner/tap.rb

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

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

@@ -1,15 +0,0 @@
-module Test
-  module Unit
-    AutoRunner.register_runner(:xml) do |auto_runner|
-      require 'test/unit/ui/xml/testrunner'
-      Test::Unit::UI::XML::TestRunner
-    end
-
-    AutoRunner.setup_option do |auto_runner, opts|
-      opts.on("--output-file-descriptor=FD", Integer,
-              "Outputs to file descriptor FD") do |fd|
-        auto_runner.runner_options[:output_file_descriptor] = fd
-      end
-    end
-  end
-end

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

@@ -1,515 +0,0 @@
-#--
-#
-# Author:: Nathaniel Talbott.
-# Copyright::
-#   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-#   * Copyright (c) 2008-2009 Kouhei Sutou <tt><kou@clear-code.com></tt>
-# 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'
-require 'test/unit/util/output'
-require 'test/unit/util/method-owner-finder'
-
-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
-      include Util::Output
-
-      STARTED = name + "::STARTED" # :nodoc:
-      FINISHED = name + "::FINISHED" # :nodoc:
-      STARTED_OBJECT = name + "::STARTED::OBJECT" # :nodoc:
-      FINISHED_OBJECT = name + "::FINISHED::OBJECT" # :nodoc:
-
-      DESCENDANTS = [] # :nodoc:
-      AVAILABLE_ORDERS = [:alphabetic, :random, :defined] # :nodoc:
-
-      class << self
-        def inherited(sub_class) # :nodoc:
-          DESCENDANTS << sub_class
-        end
-
-        @@added_methods = {}
-        def method_added(name) # :nodoc:
-          super
-          added_methods = (@@added_methods[self] ||= [])
-          stringified_name = name.to_s
-          if added_methods.include?(stringified_name)
-            attribute(:redefined, true, {}, stringified_name)
-          end
-          added_methods << stringified_name
-        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
-          suite = TestSuite.new(name, self)
-          collect_test_names.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
-
-        # Called before every test case runs. Can be used
-        # to set up fixture information used in test case
-        # scope.
-        #
-        # Here is an example test case:
-        #   class TestMyClass < Test::Unit::TestCase
-        #     class << self
-        #       def startup
-        #         ...
-        #       end
-        #     end
-        #
-        #     def setup
-        #       ...
-        #     end
-        #
-        #     def test_my_class1
-        #       ...
-        #     end
-        #
-        #     def test_my_class2
-        #       ...
-        #     end
-        #   end
-        #
-        # Here is a call order:
-        # * startup
-        # * setup
-        # * test_my_class1 (or test_my_class2)
-        # * setup
-        # * test_my_class2 (or test_my_class1)
-        #
-        # Note that you should not assume test order. Tests
-        # should be worked in any order.
-        def startup
-        end
-
-        # Called after every test case runs. Can be used to tear
-        # down fixture information used in test case scope.
-        #
-        # Here is an example test case:
-        #   class TestMyClass < Test::Unit::TestCase
-        #     class << self
-        #       def shutdown
-        #         ...
-        #       end
-        #     end
-        #
-        #     def teardown
-        #       ...
-        #     end
-        #
-        #     def test_my_class1
-        #       ...
-        #     end
-        #
-        #     def test_my_class2
-        #       ...
-        #     end
-        #   end
-        #
-        # Here is a call order:
-        # * test_my_class1 (or test_my_class2)
-        # * teardown
-        # * test_my_class2 (or test_my_class1)
-        # * teardown
-        # * shutdown
-        #
-        # Note that you should not assume test order. Tests
-        # should be worked in any order.
-        def shutdown
-        end
-
-        @@test_orders = {}
-
-        # Returns the current test order. This returns
-        # +:alphabetic+ by default.
-        def test_order
-          @@test_orders[self] || AVAILABLE_ORDERS.first
-        end
-
-        # Sets the current test order.
-        #
-        # Here are the available _order_:
-        # [:alphabetic]
-        #   Default. Tests are sorted in alphabetic order.
-        # [:random]
-        #   Tests are sorted in random order.
-        # [:defined]
-        #   Tests are sorted in defined order.
-        def test_order=(order)
-          @@test_orders[self] = order
-        end
-
-        # Defines a test in declarative syntax or marks
-        # following method as a test method.
-        #
-        # In declarative syntax usage, the following two
-        # test definitions are the almost same:
-        #
-        #   description "register user"
-        #   def test_register_user
-        #     ...
-        #   end
-        #
-        #   test "register user" do
-        #     ...
-        #   end
-        #
-        # In test method mark usage, the "my_test_method" is
-        # treated as a test method:
-        #
-        #   test
-        #   def my_test_method
-        #     assert_equal("call me", ...)
-        #   end
-        def test(*test_description_or_targets, &block)
-          if block_given?
-            test_description = test_description_or_targets.first
-            if test_description.nil?
-              raise ArgumentError, "test description is missing"
-            end
-            n_arguments = test_description_or_targets.size
-            if n_arguments > 1
-              message = "wrong number of arguments (#{n_arguments} for 1)"
-              raise ArgumentError, message
-            end
-            method_name = test_description
-            define_method(method_name, &block)
-            description(test_description, method_name)
-            attribute(:test, true, {}, method_name)
-          else
-            targets = test_description_or_targets
-            attribute(:test, true, {}, *targets)
-          end
-        end
-
-        # Describes a test.
-        #
-        # The following example associates "register a
-        # normal user" description with "test_register"
-        # test.
-        #
-        #   description "register a normal user"
-        #   def test_register
-        #     ...
-        #   end
-        def description(value, target=nil)
-          attribute(:description, value, {}, target || [])
-        end
-
-        # :stopdoc:
-        private
-        def collect_test_names
-          method_names = public_instance_methods(true).collect do |name|
-            name.to_s
-          end
-          test_names = method_names.find_all do |method_name|
-            method_name =~ /^test./ or get_attribute(method_name, :test)
-          end
-          send("sort_test_names_in_#{test_order}_order", test_names)
-        end
-
-        def sort_test_names_in_alphabetic_order(test_names)
-          test_names.sort
-        end
-
-        def sort_test_names_in_random_order(test_names)
-          test_names.sort_by {rand(test_names.size)}
-        end
-
-        def sort_test_names_in_defined_order(test_names)
-          added_methods = @@added_methods[self]
-          test_names.sort do |test1, test2|
-            test1_defined_order = added_methods.index(test1)
-            test2_defined_order = added_methods.index(test2)
-            if test1_defined_order and test2_defined_order
-              test1_defined_order <=> test2_defined_order
-            elsif test1_defined_order
-              1
-            elsif test2_defined_order
-              -1
-            else
-              test1 <=> test2
-            end
-          end
-        end
-        # :startdoc:
-      end
-
-      attr_reader :method_name, :start_time, :elapsed_time
-
-      # 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)
-        test_method = method(test_method_name)
-        throw :invalid_test if test_method.arity > 0
-        owner = Util::MethodOwnerFinder.find(self, test_method_name)
-        if owner.class != Module and self.class != owner
-          throw :invalid_test
-        end
-        @method_name = test_method_name
-        @test_passed = true
-        @interrupted = false
-        @start_time = nil
-        @elapsed_time = nil
-      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
-          @start_time = Time.now
-          yield(STARTED, name)
-          yield(STARTED_OBJECT, self)
-          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
-          @elapsed_time = Time.now - @start_time
-          result.add_run
-          yield(FINISHED, name)
-          yield(FINISHED_OBJECT, self)
-        ensure
-          # @_result = nil # For test-spec's after_all :<
-        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
-
-      # Returns a description for the test. A description
-      # will be associated by Test::Unit::TestCase.test or
-      # Test::Unit::TestCase.description.
-      #
-      # Returns a name for the test for no description test.
-      def description
-        self[:description] || 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
-
-      # 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
-
-      private
-      def current_result
-        @_result
-      end
-
-      def run_test
-        if self.class.get_attribute(@method_name, :redefined)
-          notify("#{self.class}\##{@method_name} was redefined")
-        end
-        __send__(@method_name)
-        add_pass
-      end
-
-      def handle_exception(exception)
-        self.class.exception_handlers.each do |handler|
-          return true if send(handler, exception)
-        end
-        false
-      end
-
-      def problem_occurred
-        @test_passed = false
-      end
-
-      def add_assertion
-        current_result.add_assertion
-      end
-
-      def add_pass
-        current_result.add_pass
-      end
-    end
-  end
-end