whoami7 - Manager
:
/
opt
/
alt
/
ruby19
/
lib64
/
ruby
/
1.9.1
/
test
/
Upload File:
files >> //opt/alt/ruby19/lib64/ruby/1.9.1/test/unit.rb
# 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
Copyright ©2021 || Defacer Indonesia