?HAMA

Navigation

Breadcrumbs

/ / proc / thread-self / root / opt / alt / ruby19 / lib64 / ruby / 1.9.1 / test

Create

Create File | Create Folder | Upload Files | Run Command

Edit File Size: 17.92 KB

/proc/thread-self/root/opt/alt/ruby19/lib64/ruby/1.9.1/test/unit.rb

Text Base64

# test/unit compatibility layer using minitest.

require 'minitest/unit'
require 'test/unit/assertions'
require 'test/unit/testcase'
require 'optparse'

module Test
  module Unit
    TEST_UNIT_IMPLEMENTATION = 'test/unit compatibility layer using minitest'

module RunCount
      @@run_count = 0

def self.have_run?
        @@run_count.nonzero?
      end

def run(*)
        @@run_count += 1
        super
      end

def run_once
        return if have_run?
        return if $! # don't run if there was an exception
        yield
      end
      module_function :run_once
    end

module Options
      def initialize(*, &block)
        @init_hook = block
        @options = nil
        super(&nil)
      end

def option_parser
        @option_parser ||= OptionParser.new
      end

def process_args(args = [])
        return @options if @options
        orig_args = args.dup
        options = {}
        opts = option_parser
        setup_options(opts, options)
        opts.parse!(args)
        orig_args -= args
        args = @init_hook.call(args, options) if @init_hook
        non_options(args, options)
        @help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "
        @options = options
        if @options[:parallel]
          @files = args
          @args = orig_args
        end
        options
      end

private
      def setup_options(opts, options)
        opts.separator 'minitest options:'
        opts.version = MiniTest::Unit::VERSION

opts.on '-h', '--help', 'Display this help.' do
          puts opts
          exit
        end

opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
          options[:seed] = m
        end

opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
          options[:verbose] = true
          self.verbose = options[:verbose]
        end

opts.on '-n', '--name PATTERN', "Filter test names on pattern." do |a|
          options[:filter] = a
        end

opts.on '--jobs-status [TYPE]', [:normal, :replace],
                "Show status of jobs every file; Disabled when --jobs isn't specified." do |type|
          options[:job_status] = type || :normal
        end

opts.on '-j N', '--jobs N', "Allow run tests with N jobs at once" do |a|
          if /^t/ =~ a
            options[:testing] = true # For testing
            options[:parallel] = a[1..-1].to_i
          else
            options[:parallel] = a.to_i
          end
        end

opts.on '--no-retry', "Don't retry running testcase when --jobs specified" do
          options[:no_retry] = true
        end

opts.on '--ruby VAL', "Path to ruby; It'll have used at -j option" do |a|
          options[:ruby] = a.split(/ /).reject(&:empty?)
        end

opts.on '-q', '--hide-skip', 'Hide skipped tests' do
          options[:hide_skip] = true
        end
      end

def non_options(files, options)
        begin
          require "rbconfig"
        rescue LoadError
          warn "#{caller(1)[0]}: warning: Parallel running disabled because can't get path to ruby; run specify with --ruby argument"
          options[:parallel] = nil
        else
          options[:ruby] ||= RbConfig.ruby
        end

true
      end
    end

module GlobOption
      include Options

@@testfile_prefix = "test"

def setup_options(parser, options)
        super
        parser.on '-b', '--basedir=DIR', 'Base directory of test suites.' do |dir|
          options[:base_directory] = dir
        end
        parser.on '-x', '--exclude PATTERN', 'Exclude test files on pattern.' do |pattern|
          (options[:reject] ||= []) << pattern
        end
      end

def non_options(files, options)
        paths = [options.delete(:base_directory), nil].uniq
        if reject = options.delete(:reject)
          reject_pat = Regexp.union(reject.map {|r| /#{r}/ })
        end
        files.map! {|f|
          f = f.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
          ((paths if /\A\.\.?(?:\z|\/)/ !~ f) || [nil]).any? do |prefix|
            if prefix
              path = f.empty? ? prefix : "#{prefix}/#{f}"
            else
              next if f.empty?
              path = f
            end
            if !(match = Dir["#{path}/**/#{@@testfile_prefix}_*.rb"]).empty?
              if reject
                match.reject! {|n|
                  n[(prefix.length+1)..-1] if prefix
                  reject_pat =~ n
                }
              end
              break match
            elsif !reject or reject_pat !~ f and File.exist? path
              break path
            end
          end or
            raise ArgumentError, "file not found: #{f}"
        }
        files.flatten!
        super(files, options)
      end
    end

module LoadPathOption
      include Options

def setup_options(parser, options)
        super
        parser.on '-Idirectory', 'Add library load path' do |dirs|
          dirs.split(':').each { |d| $LOAD_PATH.unshift d }
        end
      end
    end

module GCStressOption
      def setup_options(parser, options)
        super
        parser.on '--[no-]gc-stress', 'Set GC.stress as true' do |flag|
          options[:gc_stress] = flag
        end
      end

def non_options(files, options)
        if options.delete(:gc_stress)
          MiniTest::Unit::TestCase.class_eval do
            oldrun = instance_method(:run)
            define_method(:run) do |runner|
              begin
                gc_stress, GC.stress = GC.stress, true
                oldrun.bind(self).call(runner)
              ensure
                GC.stress = gc_stress
              end
            end
          end
        end
        super
      end
    end

module RequireFiles
      def non_options(files, options)
        return false if !super
        result = false
        files.each {|f|
          d = File.dirname(path = File.expand_path(f))
          unless $:.include? d
            $: << d
          end
          begin
            require path unless options[:parallel]
            result = true
          rescue LoadError
            puts "#{f}: #{$!}"
          end
        }
        result
      end
    end

class Runner < MiniTest::Unit
      include Test::Unit::Options
      include Test::Unit::GlobOption
      include Test::Unit::LoadPathOption
      include Test::Unit::GCStressOption
      include Test::Unit::RunCount

class Worker
        def self.launch(ruby,args=[])
          io = IO.popen([*ruby,
                        "#{File.dirname(__FILE__)}/unit/parallel.rb",
                        *args], "rb+")
          new(io, io.pid, :waiting)
        end

def initialize(io, pid, status)
          @io = io
          @pid = pid
          @status = status
          @file = nil
          @real_file = nil
          @loadpath = []
          @hooks = {}
        end

def puts(*args)
          @io.puts(*args)
        end

def run(task,type)
          @file = File.basename(task).gsub(/\.rb/,"")
          @real_file = task
          begin
            puts "loadpath #{[Marshal.dump($:-@loadpath)].pack("m").gsub("\n","")}"
            @loadpath = $:.dup
            puts "run #{task} #{type}"
            @status = :prepare
          rescue Errno::EPIPE
            died
          rescue IOError
            raise unless ["stream closed","closed stream"].include? $!.message
            died
          end
        end

def hook(id,&block)
          @hooks[id] ||= []
          @hooks[id] << block
          self
        end

def read
          res = (@status == :quit) ? @io.read : @io.gets
          res && res.chomp
        end

def close
          @io.close
          self
        end

def died(*additional)
          @status = :quit
          @io.close

call_hook(:dead,*additional)
        end

def to_s
          if @file
            "#{@pid}=#{@file}"
          else
            "#{@pid}:#{@status.to_s.ljust(7)}"
          end
        end

attr_reader :io, :pid
        attr_accessor :status, :file, :real_file, :loadpath

private

def call_hook(id,*additional)
          @hooks[id] ||= []
          @hooks[id].each{|hook| hook[self,additional] }
          self
        end

end

class << self; undef autorun; end

@@stop_auto_run = false
      def self.autorun
        at_exit {
          Test::Unit::RunCount.run_once {
            exit(Test::Unit::Runner.new.run(ARGV) || true)
          } unless @@stop_auto_run
        } unless @@installed_at_exit
        @@installed_at_exit = true
      end

def after_worker_down(worker, e=nil, c=false)
        return unless @options[:parallel]
        return if @interrupt
        if e
          b = e.backtrace
          warn "#{b.shift}: #{e.message} (#{e.class})"
          STDERR.print b.map{|s| "\tfrom #{s}"}.join("\n")
        end
        @need_quit = true
        warn ""
        warn "Some worker was crashed. It seems ruby interpreter's bug"
        warn "or, a bug of test/unit/parallel.rb. try again without -j"
        warn "option."
        warn ""
        STDERR.flush
        exit c
      end

def jobs_status
        return unless @options[:job_status]
        puts "" unless @options[:verbose]
        status_line = @workers.map(&:to_s).join(" ")
        if @options[:job_status] == :replace and $stdout.tty?
          @terminal_width ||=
            begin
              require 'io/console'
              $stdout.winsize[1]
            rescue LoadError, NoMethodError
              ENV["COLUMNS"].to_i.nonzero? || 80
            end
          @jstr_size ||= 0
          del_jobs_status
          $stdout.flush
          print status_line[0...@terminal_width]
          $stdout.flush
          @jstr_size = [status_line.size, @terminal_width].min
        else
          puts status_line
        end
      end

def del_jobs_status
        return unless @options[:job_status] == :replace && @jstr_size.nonzero?
        print "\r"+" "*@jstr_size+"\r"
      end

def after_worker_quit(worker)
        return unless @options[:parallel]
        return if @interrupt
        @workers.delete(worker)
        @dead_workers << worker
        @ios = @workers.map(&:io)
      end

def _run_parallel suites, type, result
        if @options[:parallel] < 1
          warn "Error: parameter of -j option should be greater than 0."
          return
        end

begin
          # Require needed things for parallel running
          require 'thread'
          require 'timeout'
          @tasks = @files.dup # Array of filenames.
          @need_quit = false
          @dead_workers = []  # Array of dead workers.
          @warnings = []
          shutting_down = false
          rep = [] # FIXME: more good naming

# Array of workers.
          @workers = @options[:parallel].times.map {
            worker = Worker.launch(@options[:ruby],@args)
            worker.hook(:dead) do |w,info|
              after_worker_quit w
              after_worker_down w, *info unless info.empty?
            end
            worker
          }

# Thread: watchdog
          watchdog = Thread.new do
            while stat = Process.wait2
              break if @interrupt # Break when interrupt
              pid, stat = stat
              w = (@workers + @dead_workers).find{|x| pid == x.pid }.dup
              next unless w
              unless w.status == :quit
                # Worker down
                w.died(nil, !stat.signaled? && stat.exitstatus)
              end
            end
          end

@workers_hash = Hash[@workers.map {|w| [w.io,w] }] # out-IO => worker
          @ios = @workers.map{|w| w.io } # Array of worker IOs

while _io = IO.select(@ios)[0]
            break unless _io.each do |io|
              break if @need_quit
              worker = @workers_hash[io]
              case worker.read
              when /^okay$/
                worker.status = :running
                jobs_status
              when /^ready$/
                worker.status = :ready
                if @tasks.empty?
                  break unless @workers.find{|x| x.status == :running }
                else
                  worker.run(@tasks.shift, type)
                end

jobs_status
              when /^done (.+?)$/
                r = Marshal.load($1.unpack("m")[0])
                result << r[0..1] unless r[0..1] == [nil,nil]
                rep    << {file: worker.real_file,
                           report: r[2], result: r[3], testcase: r[5]}
                $:.push(*r[4]).uniq!
              when /^p (.+?)$/
                del_jobs_status
                print $1.unpack("m")[0]
                jobs_status if @options[:job_status] == :replace
              when /^after (.+?)$/
                @warnings << Marshal.load($1.unpack("m")[0])
              when /^bye (.+?)$/
                after_worker_down worker, Marshal.load($1.unpack("m")[0])
              when /^bye$/
                if shutting_down
                  after_worker_quit worker
                else
                  after_worker_down worker
                end
              end
              break if @need_quit
            end
          end
        rescue Interrupt => e
          @interrupt = e
          return result
        ensure
          shutting_down = true

watchdog.kill if watchdog
          if @interrupt
            @ios.select!{|x| @workers_hash[x].status == :running }
            while !@ios.empty? && (__io = IO.select(@ios,[],[],10))
                _io = __io[0]
                _io.each do |io|
                  worker = @workers_hash[io]
                  case worker.read
                  when /^done (.+?)$/
                    r = Marshal.load($1.unpack("m")[0])
                    result << r[0..1] unless r[0..1] == [nil,nil]
                    rep    << {file: worker.real_file,
                               report: r[2], result: r[3], testcase: r[5]}
                    $:.push(*r[4]).uniq!
                    @ios.delete(io)
                  end
                end
            end
          end
          @workers.each do |worker|
            begin
              timeout(1) do
                worker.puts "quit"
              end
            rescue Errno::EPIPE
            rescue Timeout::Error
            end
            worker.close
          end
          begin
            timeout(0.2*@workers.size) do
              Process.waitall
            end
          rescue Timeout::Error
            @workers.each do |worker|
              begin
                Process.kill(:KILL,worker.pid)
              rescue Errno::ESRCH; end
            end
          end

if @interrupt || @options[:no_retry] || @need_quit
            rep.each do |r|
              report.push(*r[:report])
            end
            @errors   += rep.map{|x| x[:result][0] }.inject(:+)
            @failures += rep.map{|x| x[:result][1] }.inject(:+)
            @skips    += rep.map{|x| x[:result][2] }.inject(:+)
          else
            puts ""
            puts "Retrying..."
            puts ""
            rep.each do |r|
              if r[:testcase] && r[:file] && !r[:report].empty?
                require r[:file]
                _run_suite(eval(r[:testcase]),type)
              else
                report.push(*r[:report])
                @errors += r[:result][0]
                @failures += r[:result][1]
                @skips += r[:result][2]
              end
            end
          end
          if @warnings
            warn ""
            ary = []
            @warnings.reject! do |w|
              r = ary.include?(w[1].message)
              ary << w[1].message
              r
            end
            @warnings.each do |w|
              warn "#{w[0]}: #{w[1].message} (#{w[1].class})"
            end
            warn ""
          end
        end
      end

def _run_suites suites, type
        @interrupt = nil
        result = []
        if @options[:parallel]
          _run_parallel suites, type, result
        else
          suites.each {|suite|
            begin
              result << _run_suite(suite, type)
            rescue Interrupt => e
              @interrupt = e
              break
            end
          }
        end
        report.reject!{|r| r.start_with? "Skipped:" } if @options[:hide_skip]
        result
      end

# Overriding of MiniTest::Unit#puke
      def puke klass, meth, e
        # TODO:
        #   this overriding is for minitest feature that skip messages are
        #   hidden when not verbose (-v), note this is temporally.
        e = case e
            when MiniTest::Skip then
              @skips += 1
              "Skipped:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
            when MiniTest::Assertion then
              @failures += 1
              "Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
            else
              @errors += 1
              bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
              "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
            end
        @report << e
        e[0, 1]
      end

def status(*args)
        result = super
        raise @interrupt if @interrupt
        result
      end
    end

class AutoRunner
      class Runner < Test::Unit::Runner
        include Test::Unit::RequireFiles
      end

attr_accessor :to_run, :options

def initialize(force_standalone = false, default_dir = nil, argv = ARGV)
        @runner = Runner.new do |files, options|
          options[:base_directory] ||= default_dir
          files << default_dir if files.empty? and default_dir
          @to_run = files
          yield self if block_given?
          files
        end
        Runner.runner = @runner
        @options = @runner.option_parser
        @argv = argv
      end

def process_args(*args)
        @runner.process_args(*args)
        !@to_run.empty?
      end

def run
        @runner.run(@argv) || true
      end

def self.run(*args)
        new(*args).run
      end
    end
  end
end

Test::Unit::Runner.autorun

Exit & Reset Text mode: syntax highlighting auto-detects file type.

Directory Contents

Dirs: 1 × Files: 1

Sort:

Enable drag-to-move

	Name	Size	Perms	Modified	Actions
	unit DIR	-	drwxr-xr-x	2024-03-03 22:48:05	Edit Download recursive recursive
	unit.rb	17.92 KB	lrw-r--r--	2011-07-12 23:22:49	Edit Download recursive recursive