glib2 0.90.7-x86-mingw32 → 0.90.8-x86-mingw32

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

@@ -83,6 +83,14 @@ module Test
         collector.collect(*auto_runner.to_run)
       end
 
+      # JUST TEST!
+      # register_collector(:xml) do |auto_runner|
+      #   require 'test/unit/collector/xml'
+      #   collector = Collector::XML.new
+      #   collector.filter = auto_runner.filters
+      #   collector.collect(auto_runner.to_run[0])
+      # end
+
       # deprecated
       register_collector(:object_space) do |auto_runner|
         require 'test/unit/collector/objectspace'
@@ -159,6 +167,13 @@ module Test
             @runner = r
           end
 
+          o.on
+          o.on('--collector=COLLECTOR', COLLECTORS,
+               "Use the given COLLECTOR.",
+               "(" + keyword_display(COLLECTORS) + ")") do |collector|
+            @collector = collector
+          end
+
           if (@standalone)
             o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
               @base = b
@@ -199,6 +214,18 @@ module Test
             end
           end
 
+          o.on('--ignore-name=NAME', String,
+               "Ignores tests matching NAME.",
+               "(patterns may be used).") do |n|
+            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+            case n
+            when Regexp
+              @filters << proc {|t| n =~ t.method_name ? false : true}
+            else
+              @filters << proc {|t| n != t.method_name}
+            end
+          end
+
           o.on('-t', '--testcase=TESTCASE', String,
                "Runs tests in TestCases matching TESTCASE.",
                "(patterns may be used).") do |n|
@@ -211,6 +238,18 @@ module Test
             end
           end
 
+          o.on('--ignore-testcase=TESTCASE', String,
+               "Ignores tests in TestCases matching TESTCASE.",
+               "(patterns may be used).") do |n|
+            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
+            case n
+            when Regexp
+              @filters << proc {|t| n =~ t.class.name ? false : true}
+            else
+              @filters << proc {|t| n != t.class.name}
+            end
+          end
+
           priority_filter = Proc.new do |test|
             if @filters == [priority_filter]
               Priority::Checker.new(test).need_to_run?
@@ -373,3 +412,4 @@ end
 require 'test/unit/runner/console'
 require 'test/unit/runner/emacs'
 require 'test/unit/runner/tap'
+require 'test/unit/runner/xml'

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

@@ -15,9 +15,9 @@ module Test
       end
 
       def add_suite(destination, suite)
-        to_delete = suite.tests.find_all{|t| !include?(t)}
-        to_delete.each{|t| suite.delete(t)}
-        destination << suite unless(suite.size == 0)
+        to_delete = suite.tests.find_all {|t| !include?(t)}
+        to_delete.each {|t| suite.delete(t)}
+        destination << suite unless suite.empty?
       end
 
       def include?(test)
@@ -29,7 +29,9 @@ module Test
       end
 
       def sort(suites)
-        suites.sort_by {|suite| suite.name || suite.to_s}
+        suites.sort_by do |suite|
+          [suite.priority, suite.name || suite.to_s]
+        end
       end
     end
   end

data/test-unit/lib/test/unit/collector/load.rb

@@ -18,6 +18,7 @@ module Test
           @patterns = [/\Atest[_\-].+\.rb\z/m, /[_\-]test\.rb\z/]
           @excludes = []
           @base = nil
+          @require_failed_infos = []
         end
 
         def base=(base)
@@ -39,16 +40,18 @@ module Test
                 collect_file(from, test_suites, already_gathered)
               end
             end
+            add_require_failed_test_suite(test_suites)
 
             if test_suites.size > 1
               test_suite = TestSuite.new("[#{froms.join(', ')}]")
               sort(test_suites).each do |sub_test_suite|
                 test_suite << sub_test_suite
               end
-              test_suite
             else
-              test_suites.first
+              test_suite = test_suites.first
             end
+
+            test_suite
           end
         end
 
@@ -95,9 +98,14 @@ module Test
 
         def collect_file(path, test_suites, already_gathered)
           @program_file ||= File.expand_path($0)
-          return if @program_file == path.expand_path.to_s
-          add_load_path(path.expand_path.dirname) do
-            require(path.to_s)
+          expanded_path = path.expand_path
+          return if @program_file == expanded_path.to_s
+          add_load_path(expanded_path.dirname) do
+            begin
+              require(path.to_s)
+            rescue LoadError
+              @require_failed_infos << {:path => expanded_path, :exception => $!}
+            end
             find_test_cases(already_gathered).each do |test_case|
               add_suite(test_suites, test_case.suite)
             end
@@ -138,6 +146,41 @@ module Test
 
           false
         end
+
+        def add_require_failed_test_suite(test_suites)
+          return if @require_failed_infos.empty?
+
+          require_failed_infos = @require_failed_infos
+          require_failed_omissions = Class.new(Test::Unit::TestCase)
+          require_failed_omissions.class_eval do
+            class << self
+              def name
+                "RequireFailedOmissions"
+              end
+            end
+
+            require_failed_infos.each do |info|
+              path = info[:path]
+              normalized_path = path.to_s.gsub(/[^a-z0-9\_]+/i, '_')
+              normalized_path = normalized_path.gsub(/\A_+/, '')
+              exception = info[:exception]
+              define_method("test_require_#{normalized_path}") do
+                @require_failed_exception = exception
+                omit("failed to load: <#{path}>: <#{exception.message}>")
+              end
+            end
+
+            def priority
+              100
+            end
+
+            def filter_backtrace(location)
+              super(@require_failed_exception.backtrace)
+            end
+          end
+
+          add_suite(test_suites, require_failed_omissions.suite)
+        end
       end
     end
   end

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

@@ -0,0 +1,250 @@
+#--
+#
+# Author:: Kouhei Sutou
+# Copyright::
+#   * Copyright (c) 2011 Kouhei Sutou <kou@clear-code.com>
+# License:: Ruby license.
+
+# just test!!! don't use it yet!!!
+
+require 'test/unit/collector'
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module Test
+  module Unit
+    module Collector
+      class XML
+        include Collector
+
+        def collect(xml_log_path)
+          listener = Listener.new
+          File.open(xml_log_path) do |xml_log|
+            parser = REXML::Parsers::StreamParser.new(xml_log, listener)
+            parser.parse
+          end
+          suite = TestSuite.new("tests in #{xml_log_path}")
+          suites = listener.test_suites
+          sort(suites).each {|s| add_suite(suite, s)}
+          suite
+        end
+
+        class Listener
+          include REXML::StreamListener
+
+          attr_reader :test_suites
+          def initialize
+            @ns_stack = [{"xml" => :xml}]
+            @tag_stack = [["", :root]]
+            @text_stack = ['']
+            @state_stack = [:root]
+            @values = {}
+            @test_suites = []
+          end
+
+          def tag_start(name, attributes)
+            @text_stack.push('')
+
+            ns = @ns_stack.last.dup
+            attrs = {}
+            attributes.each do |n, v|
+              if /\Axmlns(?:\z|:)/ =~ n
+                ns[$POSTMATCH] = v
+              else
+                attrs[n] = v
+              end
+            end
+            @ns_stack.push(ns)
+
+            _parent_tag = parent_tag
+            prefix, local = split_name(name)
+            uri = _ns(ns, prefix)
+            @tag_stack.push([uri, local])
+
+            state = next_state(@state_stack.last, uri, local)
+            @state_stack.push(state)
+            case state
+            when :test_suite, :test_case
+              @values = {}
+            when :test
+              @values = {}
+              @n_pass_assertions = 0 if _parent_tag == "start-test"
+            when :backtrace
+              @backtrace = []
+              @values_backup = @values
+              @values = {}
+            end
+          end
+
+          def tag_end(name)
+            state = @state_stack.pop
+            text = @text_stack.pop
+            uri, local = @tag_stack.pop
+            no_action_states = [:root, :stream]
+            case state
+            when *no_action_states
+              # do nothing
+            when :test_suite
+              test_suite_end
+            when :complete_test_case
+              @test_suites.last << @test_case.suite
+            when :test_case
+              test_case_end
+            when :result
+              @result = @values
+            when :test
+              test_end
+            when :pass_assertion
+              @n_pass_assertions += 1
+            when :backtrace
+              @values = @values_backup
+              @values["backtrace"] = @backtrace
+            when :entry
+              file = @values['file']
+              line = @values['line']
+              info = @values['info']
+              @backtrace << "#{file}:#{line}: #{info}"
+              @values = {}
+            else
+              local = normalize_local(local)
+              @values[local] = text
+            end
+            @ns_stack.pop
+          end
+
+          def text(data)
+            @text_stack.last << data
+          end
+
+          private
+          def _ns(ns, prefix)
+            ns.fetch(prefix, "")
+          end
+
+          NAME_SPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
+          def split_name(name)
+            name =~ NAME_SPLIT
+            [$1 || '', $2]
+          end
+
+          STATE_TABLE = {
+            :root => [:stream],
+            :stream => [:ready_test_suite,
+                        :start_test_suite,
+                        :ready_test_case,
+                        :start_test_case,
+                        :start_test,
+                        :pass_assertion,
+                        :test_result,
+                        :complete_test,
+                        :complete_test_case,
+                        :complete_test_suite,
+                        :success],
+            :ready_test_suite => [:n_tests],
+            :start_test_suite => [:test_suite],
+            :ready_test_case => [:test_case,
+                                 :n_tests],
+            :start_test_case => [:test_case],
+            :start_test => [:test],
+            :pass_assertion => [:test],
+            :complete_test => [:test, :success],
+            :complete_test_case => [:test_case,
+                                    :elapsed,
+                                    :success],
+            :complete_test_suite => [:test_suite,
+                                     :success],
+            :test_suite => [:start_time,
+                            :elapsed],
+            :test_case => [:name,
+                           :start_time,
+                           :elapsed],
+            :test => [:name,
+                      :start_time,
+                      :elapsed],
+            :test_result => [:test,
+                             :result],
+            :result => [:test_case,
+                        :test,
+                        :status,
+                        :backtrace,
+                        :detail],
+            :backtrace => [:entry],
+            :entry => [:file,
+                       :line,
+                       :info],
+          }
+          def next_state(current_state, uri, local)
+            local = normalize_local(local)
+            valid_elements = STATE_TABLE[current_state]
+            if valid_elements.nil?
+              raise "unexpected element: #{current_path}"
+            end
+            next_state = local.to_sym
+            unless valid_elements.include?(next_state)
+              raise "unexpected element: #{current_path}"
+            end
+            next_state
+          end
+
+          def current_path
+            locals = @tag_stack.collect do |uri, local|
+              local
+            end
+            ["", *locals].join("/")
+          end
+
+          def normalize_local(local)
+            local.gsub(/-/, "_")
+          end
+
+          def parent_tag
+            @tag_stack.last[1]
+          end
+
+          def test_suite_end
+            return unless parent_tag == "start-test-suite"
+            suite = TestSuite.new
+            ["start_time", "elapsed_time", "n_tests"].each do |key|
+              if @values.has_key?(key)
+                suite.instance_variable_set("@#{key}", @values[key])
+              end
+            end
+            @test_suites << suite
+          end
+
+          def test_case_end
+            return unless parent_tag == "start-test-case"
+            name = @values["name"]
+            @test_case = Class.new(TestCase) do
+              define_method(:name) do
+                name
+              end
+            end
+          end
+
+          def test_end
+            return unless parent_tag == "complete-test"
+            name = @values["name"]
+            n_pass_assertions = @n_pass_assertions
+            result = @result
+            @test_case.module_eval do
+              test
+              define_method(name) do
+                n_pass_assertions.times do
+                  add_assertion
+                end
+                case result["status"]
+                when "omission"
+                  add_omission(Omission.new(name,
+                                            result["backtrace"],
+                                            result["detail"]))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -48,13 +48,14 @@ module Test
 
       # Returns a verbose version of the error description.
       def long_display
-        backtrace_display = backtrace.join("\n    ")
+        backtrace_display = location.join("\n    ")
         "#{label}:\n#@test_name:\n#{message}\n    #{backtrace_display}"
       end
 
-      def backtrace
-        filter_backtrace(@exception.backtrace)
+      def location
+        @location ||= filter_backtrace(@exception.backtrace)
       end
+      alias_method :backtrace, :location # Deprecated
 
       # Overridden to return long_display.
       def to_s