glib2 0.90.8 → 0.90.9

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

@@ -1,38 +0,0 @@
-module Test
-  module Unit
-    module Collector
-      def initialize
-        @filters = []
-      end
-
-      def filter=(filters)
-        @filters = case(filters)
-          when Proc
-            [filters]
-          when Array
-            filters
-        end
-      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.empty?
-      end
-
-      def include?(test)
-        return true if(@filters.empty?)
-        @filters.each do |filter|
-          return false if filter[test] == false
-        end
-        true
-      end
-
-      def sort(suites)
-        suites.sort_by do |suite|
-          [suite.priority, suite.name || suite.to_s]
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class Descendant
-        include Collector
-
-        NAME = 'collected from the subclasses of TestCase'
-
-        def collect(name=NAME)
-          suite = TestSuite.new(name)
-          sub_suites = []
-          TestCase::DESCENDANTS.each do |descendant_test_case|
-            add_suite(sub_suites, descendant_test_case.suite)
-          end
-          sort(sub_suites).each {|s| suite << s}
-          suite
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-require 'test/unit/testsuite'
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class Dir
-        include Collector
-
-        attr_reader :pattern, :exclude
-        attr_accessor :base
-
-        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
-          super()
-          @dir = dir
-          @file = file
-          @object_space = object_space
-          @req = req
-          @pattern = [/\btest_.*\.rb\Z/m]
-          @exclude = []
-          @base = nil
-        end
-
-        def collect(*from)
-          basedir = @base
-          $:.push(basedir) if basedir
-          if(from.empty?)
-            recursive_collect('.', find_test_cases)
-          elsif(from.size == 1)
-            recursive_collect(from.first, find_test_cases)
-          else
-            suites = []
-            from.each do |f|
-              suite = recursive_collect(f, find_test_cases)
-              suites << suite unless(suite.tests.empty?)
-            end
-            suite = TestSuite.new("[#{from.join(', ')}]")
-            sort(suites).each{|s| suite << s}
-            suite
-          end
-        ensure
-          $:.delete_at($:.rindex(basedir)) if basedir
-        end
-
-        def find_test_cases(ignore=[])
-          cases = []
-          @object_space.each_object(Class) do |c|
-            cases << c if(c < TestCase && !ignore.include?(c))
-          end
-          ignore.concat(cases)
-          cases
-        end
-
-        def recursive_collect(name, already_gathered)
-          sub_suites = []
-          path = realdir(name)
-          if @file.directory?(path)
-	    dir_name = name unless name == '.'
-            @dir.entries(path).each do |e|
-              next if(e == '.' || e == '..')
-              e_name = dir_name ? @file.join(dir_name, e) : e
-              if @file.directory?(realdir(e_name))
-                next if /\A(?:CVS|\.svn|\.git)\z/ =~ e
-                sub_suite = recursive_collect(e_name, already_gathered)
-                sub_suites << sub_suite unless(sub_suite.empty?)
-              else
-                next if /~\z/ =~ e_name or /\A\.\#/ =~ e
-                if @pattern and !@pattern.empty?
-                  next unless @pattern.any? {|pat| pat =~ e_name}
-                end
-                if @exclude and !@exclude.empty?
-                  next if @exclude.any? {|pat| pat =~ e_name}
-                end
-                collect_file(e_name, sub_suites, already_gathered)
-              end
-            end
-          else
-            collect_file(name, sub_suites, already_gathered)
-          end
-          suite = TestSuite.new(@file.basename(name))
-          sort(sub_suites).each{|s| suite << s}
-          suite
-        end
-
-        def collect_file(name, suites, already_gathered)
-          dir = @file.dirname(@file.expand_path(name, @base))
-          $:.unshift(dir)
-          if(@req)
-            @req.require(name)
-          else
-            require(name)
-          end
-          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
-        ensure
-          $:.delete_at($:.rindex(dir)) if(dir)
-        end
-
-	def realdir(path)
-	  if @base
-	    @file.join(@base, path)
-	  else
-	    path
-	  end
-	end
-      end
-    end
-  end
-end

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

@@ -1,187 +0,0 @@
-require 'pathname'
-
-require 'test/unit/testsuite'
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class Load
-        include Collector
-
-        attr_reader :patterns, :excludes, :base
-
-        def initialize
-          super
-          @system_excludes = [/~\z/, /\A\.\#/]
-          @system_directory_excludes = [/\A(?:CVS|\.svn|\.git)\z/]
-          @patterns = [/\Atest[_\-].+\.rb\z/m, /[_\-]test\.rb\z/]
-          @excludes = []
-          @base = nil
-          @require_failed_infos = []
-        end
-
-        def base=(base)
-          base = Pathname(base) unless base.nil?
-          @base = base
-        end
-
-        def collect(*froms)
-          add_load_path(@base) do
-            froms = ["."] if froms.empty?
-            test_suites = []
-            already_gathered = find_test_cases
-            froms.each do |from|
-              from = resolve_path(from)
-              if from.directory?
-                test_suite = collect_recursive(from, already_gathered)
-                test_suites << test_suite unless test_suite.tests.empty?
-              else
-                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
-            else
-              test_suite = test_suites.first
-            end
-
-            test_suite
-          end
-        end
-
-        def find_test_cases(ignore=[])
-          test_cases = []
-          TestCase::DESCENDANTS.each do |test_case|
-            test_cases << test_case unless ignore.include?(test_case)
-          end
-          ignore.concat(test_cases)
-          test_cases
-        end
-
-        private
-        def collect_recursive(path, already_gathered)
-          sub_test_suites = []
-
-          if path.directory?
-            directories, files = path.children.partition do |child|
-              child.directory?
-            end
-
-            files.each do |child|
-              next if excluded_file?(child.basename.to_s)
-              collect_file(child, sub_test_suites, already_gathered)
-            end
-
-            directories.each do |child|
-              next if excluded_directory?(child.basename.to_s)
-              sub_test_suite = collect_recursive(child, already_gathered)
-              sub_test_suites << sub_test_suite unless sub_test_suite.empty?
-            end
-          else
-            unless excluded_file?(path.basename.to_s)
-              collect_file(path, sub_test_suites, already_gathered)
-            end
-          end
-
-          test_suite = TestSuite.new(path.basename.to_s)
-          sort(sub_test_suites).each do |sub_test_suite|
-            test_suite << sub_test_suite
-          end
-          test_suite
-        end
-
-        def collect_file(path, test_suites, already_gathered)
-          @program_file ||= File.expand_path($0)
-          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
-          end
-        end
-
-        def resolve_path(path)
-          if @base
-            @base + path
-          else
-            Pathname(path)
-          end
-        end
-
-        def add_load_path(path)
-          $LOAD_PATH.push(path.to_s) if path
-          yield
-        ensure
-          $LOAD_PATH.delete_at($LOAD_PATH.rindex(path.to_s)) if path
-        end
-
-        def excluded_directory?(base)
-          @system_directory_excludes.any? {|pattern| pattern =~ base}
-        end
-
-        def excluded_file?(base)
-          return true if @system_excludes.any? {|pattern| pattern =~ base}
-
-          patterns = @patterns || []
-          unless patterns.empty?
-            return true unless patterns.any? {|pattern| pattern =~ base}
-          end
-
-          excludes = @excludes || []
-          unless excludes.empty?
-            return true if excludes.any? {|pattern| pattern =~ base}
-          end
-
-          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
-end

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

@@ -1,34 +0,0 @@
-# Author:: Nathaniel Talbott.
-# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
-# License:: Ruby license.
-
-require 'test/unit/collector'
-
-module Test
-  module Unit
-    module Collector
-      class ObjectSpace
-        include Collector
-        
-        NAME = 'collected from the ObjectSpace'
-        
-        def initialize(source=::ObjectSpace)
-          super()
-          @source = source
-        end
-        
-        def collect(name=NAME)
-          suite = TestSuite.new(name)
-          sub_suites = []
-          @source.each_object(Class) do |klass|
-            if(Test::Unit::TestCase > klass)
-              add_suite(sub_suites, klass.suite)
-            end
-          end
-          sort(sub_suites).each{|s| suite << s}
-          suite
-        end
-      end
-    end
-  end
-end

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

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