← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

« back to all changes in this revision

Viewing changes to lib/test/unit.rb

  • Committer: Bazaar Package Importer
  • Author(s): Lucas Nussbaum
  • Date: 2011-09-24 19:16:17 UTC
  • mfrom: (1.1.8 upstream) (13.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20110924191617-o1qz4rcmqjot8zuy
Tags: 1.9.3~rc1-1
http://bugs.debian.org/639959
* New upstream release: 1.9.3 RC1.
  + Includes load.c fixes. Closes: #639959.
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/test/unit.rb
3
3
require 'minitest/unit'
4
4
require 'test/unit/assertions'
5
5
require 'test/unit/testcase'
 
6
require 'optparse'
6
7
 
7
8
module Test
8
9
  module Unit
9
10
    TEST_UNIT_IMPLEMENTATION = 'test/unit compatibility layer using minitest'
10
11
 
11
 
    def self.setup_argv(original_argv=ARGV)
12
 
      minitest_argv = []
13
 
      files = []
14
 
      reject = []
15
 
      original_argv = original_argv.dup
16
 
      while arg = original_argv.shift
17
 
        case arg
18
 
        when '-v'
19
 
          minitest_argv << arg
20
 
        when /\A(-n)(.+)?/, /\A(--name)=?\b(.+)?/
21
 
          minitest_argv << $1
22
 
          minitest_argv << ($2 || original_argv.shift)
23
 
        when /\A-x(.+)?/
24
 
          reject << ($1 || original_argv.shift)
25
 
        else
26
 
          files << arg
27
 
        end
28
 
      end
29
 
 
30
 
      if block_given?
31
 
        files = yield files
32
 
      end
33
 
 
34
 
      files.map! {|f|
35
 
        f = f.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
36
 
        if File.directory? f
37
 
          Dir["#{f}/**/test_*.rb"]
38
 
        elsif File.file? f
39
 
          f
40
 
        else
41
 
          raise ArgumentError, "file not found: #{f}"
42
 
        end
43
 
      }
44
 
      files.flatten!
45
 
 
46
 
      reject_pat = Regexp.union(reject.map {|r| /#{r}/ })
47
 
      files.reject! {|f| reject_pat =~ f }
48
 
 
49
 
      files.each {|f|
50
 
        d = File.dirname(path = File.expand_path(f))
51
 
        unless $:.include? d
52
 
          $: << d
53
 
        end
 
12
    module RunCount
 
13
      @@run_count = 0
 
14
 
 
15
      def self.have_run?
 
16
        @@run_count.nonzero?
 
17
      end
 
18
 
 
19
      def run(*)
 
20
        @@run_count += 1
 
21
        super
 
22
      end
 
23
 
 
24
      def run_once
 
25
        return if have_run?
 
26
        return if $! # don't run if there was an exception
 
27
        yield
 
28
      end
 
29
      module_function :run_once
 
30
    end
 
31
 
 
32
    module Options
 
33
      def initialize(*, &block)
 
34
        @init_hook = block
 
35
        @options = nil
 
36
        super(&nil)
 
37
      end
 
38
 
 
39
      def option_parser
 
40
        @option_parser ||= OptionParser.new
 
41
      end
 
42
 
 
43
      def process_args(args = [])
 
44
        return @options if @options
 
45
        orig_args = args.dup
 
46
        options = {}
 
47
        opts = option_parser
 
48
        setup_options(opts, options)
 
49
        opts.parse!(args)
 
50
        orig_args -= args
 
51
        args = @init_hook.call(args, options) if @init_hook
 
52
        non_options(args, options)
 
53
        @help = orig_args.map { |s| s =~ /[\s|&<>$()]/ ? s.inspect : s }.join " "
 
54
        @options = options
 
55
        if @options[:parallel]
 
56
          @files = args
 
57
          @args = orig_args
 
58
        end
 
59
        options
 
60
      end
 
61
 
 
62
      private
 
63
      def setup_options(opts, options)
 
64
        opts.separator 'minitest options:'
 
65
        opts.version = MiniTest::Unit::VERSION
 
66
 
 
67
        opts.on '-h', '--help', 'Display this help.' do
 
68
          puts opts
 
69
          exit
 
70
        end
 
71
 
 
72
        opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
 
73
          options[:seed] = m
 
74
        end
 
75
 
 
76
        opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
 
77
          options[:verbose] = true
 
78
          self.verbose = options[:verbose]
 
79
        end
 
80
 
 
81
        opts.on '-n', '--name PATTERN', "Filter test names on pattern." do |a|
 
82
          options[:filter] = a
 
83
        end
 
84
 
 
85
        opts.on '--jobs-status [TYPE]', [:normal, :replace],
 
86
                "Show status of jobs every file; Disabled when --jobs isn't specified." do |type|
 
87
          options[:job_status] = type || :normal
 
88
        end
 
89
 
 
90
        opts.on '-j N', '--jobs N', "Allow run tests with N jobs at once" do |a|
 
91
          if /^t/ =~ a
 
92
            options[:testing] = true # For testing
 
93
            options[:parallel] = a[1..-1].to_i
 
94
          else
 
95
            options[:parallel] = a.to_i
 
96
          end
 
97
        end
 
98
 
 
99
        opts.on '--no-retry', "Don't retry running testcase when --jobs specified" do
 
100
          options[:no_retry] = true
 
101
        end
 
102
 
 
103
        opts.on '--ruby VAL', "Path to ruby; It'll have used at -j option" do |a|
 
104
          options[:ruby] = a.split(/ /).reject(&:empty?)
 
105
        end
 
106
 
 
107
        opts.on '-q', '--hide-skip', 'Hide skipped tests' do
 
108
          options[:hide_skip] = true
 
109
        end
 
110
      end
 
111
 
 
112
      def non_options(files, options)
54
113
        begin
55
 
          require path
 
114
          require "rbconfig"
56
115
        rescue LoadError
57
 
          puts "#{f}: #{$!}"
58
 
        end
59
 
      }
60
 
 
61
 
      ARGV.replace minitest_argv
 
116
          warn "#{caller(1)[0]}: warning: Parallel running disabled because can't get path to ruby; run specify with --ruby argument"
 
117
          options[:parallel] = nil
 
118
        else
 
119
          options[:ruby] ||= RbConfig.ruby
 
120
        end
 
121
 
 
122
        true
 
123
      end
 
124
    end
 
125
 
 
126
    module GlobOption
 
127
      include Options
 
128
 
 
129
      @@testfile_prefix = "test"
 
130
 
 
131
      def setup_options(parser, options)
 
132
        super
 
133
        parser.on '-b', '--basedir=DIR', 'Base directory of test suites.' do |dir|
 
134
          options[:base_directory] = dir
 
135
        end
 
136
        parser.on '-x', '--exclude PATTERN', 'Exclude test files on pattern.' do |pattern|
 
137
          (options[:reject] ||= []) << pattern
 
138
        end
 
139
      end
 
140
 
 
141
      def non_options(files, options)
 
142
        paths = [options.delete(:base_directory), nil].uniq
 
143
        if reject = options.delete(:reject)
 
144
          reject_pat = Regexp.union(reject.map {|r| /#{r}/ })
 
145
        end
 
146
        files.map! {|f|
 
147
          f = f.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
 
148
          ((paths if /\A\.\.?(?:\z|\/)/ !~ f) || [nil]).any? do |prefix|
 
149
            if prefix
 
150
              path = f.empty? ? prefix : "#{prefix}/#{f}"
 
151
            else
 
152
              next if f.empty?
 
153
              path = f
 
154
            end
 
155
            if !(match = Dir["#{path}/**/#{@@testfile_prefix}_*.rb"]).empty?
 
156
              if reject
 
157
                match.reject! {|n|
 
158
                  n[(prefix.length+1)..-1] if prefix
 
159
                  reject_pat =~ n
 
160
                }
 
161
              end
 
162
              break match
 
163
            elsif !reject or reject_pat !~ f and File.exist? path
 
164
              break path
 
165
            end
 
166
          end or
 
167
            raise ArgumentError, "file not found: #{f}"
 
168
        }
 
169
        files.flatten!
 
170
        super(files, options)
 
171
      end
 
172
    end
 
173
 
 
174
    module LoadPathOption
 
175
      include Options
 
176
 
 
177
      def setup_options(parser, options)
 
178
        super
 
179
        parser.on '-Idirectory', 'Add library load path' do |dirs|
 
180
          dirs.split(':').each { |d| $LOAD_PATH.unshift d }
 
181
        end
 
182
      end
 
183
    end
 
184
 
 
185
    module GCStressOption
 
186
      def setup_options(parser, options)
 
187
        super
 
188
        parser.on '--[no-]gc-stress', 'Set GC.stress as true' do |flag|
 
189
          options[:gc_stress] = flag
 
190
        end
 
191
      end
 
192
 
 
193
      def non_options(files, options)
 
194
        if options.delete(:gc_stress)
 
195
          MiniTest::Unit::TestCase.class_eval do
 
196
            oldrun = instance_method(:run)
 
197
            define_method(:run) do |runner|
 
198
              begin
 
199
                gc_stress, GC.stress = GC.stress, true
 
200
                oldrun.bind(self).call(runner)
 
201
              ensure
 
202
                GC.stress = gc_stress
 
203
              end
 
204
            end
 
205
          end
 
206
        end
 
207
        super
 
208
      end
 
209
    end
 
210
 
 
211
    module RequireFiles
 
212
      def non_options(files, options)
 
213
        return false if !super
 
214
        result = false
 
215
        files.each {|f|
 
216
          d = File.dirname(path = File.expand_path(f))
 
217
          unless $:.include? d
 
218
            $: << d
 
219
          end
 
220
          begin
 
221
            require path unless options[:parallel]
 
222
            result = true
 
223
          rescue LoadError
 
224
            puts "#{f}: #{$!}"
 
225
          end
 
226
        }
 
227
        result
 
228
      end
 
229
    end
 
230
 
 
231
    class Runner < MiniTest::Unit
 
232
      include Test::Unit::Options
 
233
      include Test::Unit::GlobOption
 
234
      include Test::Unit::LoadPathOption
 
235
      include Test::Unit::GCStressOption
 
236
      include Test::Unit::RunCount
 
237
 
 
238
      class Worker
 
239
        def self.launch(ruby,args=[])
 
240
          io = IO.popen([*ruby,
 
241
                        "#{File.dirname(__FILE__)}/unit/parallel.rb",
 
242
                        *args], "rb+")
 
243
          new(io, io.pid, :waiting)
 
244
        end
 
245
 
 
246
        def initialize(io, pid, status)
 
247
          @io = io
 
248
          @pid = pid
 
249
          @status = status
 
250
          @file = nil
 
251
          @real_file = nil
 
252
          @loadpath = []
 
253
          @hooks = {}
 
254
        end
 
255
 
 
256
        def puts(*args)
 
257
          @io.puts(*args)
 
258
        end
 
259
 
 
260
        def run(task,type)
 
261
          @file = File.basename(task).gsub(/\.rb/,"")
 
262
          @real_file = task
 
263
          begin
 
264
            puts "loadpath #{[Marshal.dump($:-@loadpath)].pack("m").gsub("\n","")}"
 
265
            @loadpath = $:.dup
 
266
            puts "run #{task} #{type}"
 
267
            @status = :prepare
 
268
          rescue Errno::EPIPE
 
269
            died
 
270
          rescue IOError
 
271
            raise unless ["stream closed","closed stream"].include? $!.message
 
272
            died
 
273
          end
 
274
        end
 
275
 
 
276
        def hook(id,&block)
 
277
          @hooks[id] ||= []
 
278
          @hooks[id] << block
 
279
          self
 
280
        end
 
281
 
 
282
        def read
 
283
          res = (@status == :quit) ? @io.read : @io.gets
 
284
          res && res.chomp
 
285
        end
 
286
 
 
287
        def close
 
288
          @io.close
 
289
          self
 
290
        end
 
291
 
 
292
        def died(*additional)
 
293
          @status = :quit
 
294
          @io.close
 
295
 
 
296
          call_hook(:dead,*additional)
 
297
        end
 
298
 
 
299
        def to_s
 
300
          if @file
 
301
            "#{@pid}=#{@file}"
 
302
          else
 
303
            "#{@pid}:#{@status.to_s.ljust(7)}"
 
304
          end
 
305
        end
 
306
 
 
307
        attr_reader :io, :pid
 
308
        attr_accessor :status, :file, :real_file, :loadpath
 
309
 
 
310
        private
 
311
 
 
312
        def call_hook(id,*additional)
 
313
          @hooks[id] ||= []
 
314
          @hooks[id].each{|hook| hook[self,additional] }
 
315
          self
 
316
        end
 
317
 
 
318
      end
 
319
 
 
320
      class << self; undef autorun; end
 
321
 
 
322
      @@stop_auto_run = false
 
323
      def self.autorun
 
324
        at_exit {
 
325
          Test::Unit::RunCount.run_once {
 
326
            exit(Test::Unit::Runner.new.run(ARGV) || true)
 
327
          } unless @@stop_auto_run
 
328
        } unless @@installed_at_exit
 
329
        @@installed_at_exit = true
 
330
      end
 
331
 
 
332
      def after_worker_down(worker, e=nil, c=false)
 
333
        return unless @options[:parallel]
 
334
        return if @interrupt
 
335
        if e
 
336
          b = e.backtrace
 
337
          warn "#{b.shift}: #{e.message} (#{e.class})"
 
338
          STDERR.print b.map{|s| "\tfrom #{s}"}.join("\n")
 
339
        end
 
340
        @need_quit = true
 
341
        warn ""
 
342
        warn "Some worker was crashed. It seems ruby interpreter's bug"
 
343
        warn "or, a bug of test/unit/parallel.rb. try again without -j"
 
344
        warn "option."
 
345
        warn ""
 
346
        STDERR.flush
 
347
        exit c
 
348
      end
 
349
 
 
350
      def jobs_status
 
351
        return unless @options[:job_status]
 
352
        puts "" unless @options[:verbose]
 
353
        status_line = @workers.map(&:to_s).join(" ")
 
354
        if @options[:job_status] == :replace and $stdout.tty?
 
355
          @terminal_width ||=
 
356
            begin
 
357
              require 'io/console'
 
358
              $stdout.winsize[1]
 
359
            rescue LoadError, NoMethodError
 
360
              ENV["COLUMNS"].to_i.nonzero? || 80
 
361
            end
 
362
          @jstr_size ||= 0
 
363
          del_jobs_status
 
364
          $stdout.flush
 
365
          print status_line[0...@terminal_width]
 
366
          $stdout.flush
 
367
          @jstr_size = [status_line.size, @terminal_width].min
 
368
        else
 
369
          puts status_line
 
370
        end
 
371
      end
 
372
 
 
373
      def del_jobs_status
 
374
        return unless @options[:job_status] == :replace && @jstr_size.nonzero?
 
375
        print "\r"+" "*@jstr_size+"\r"
 
376
      end
 
377
 
 
378
      def after_worker_quit(worker)
 
379
        return unless @options[:parallel]
 
380
        return if @interrupt
 
381
        @workers.delete(worker)
 
382
        @dead_workers << worker
 
383
        @ios = @workers.map(&:io)
 
384
      end
 
385
 
 
386
      def _run_parallel suites, type, result
 
387
        if @options[:parallel] < 1
 
388
          warn "Error: parameter of -j option should be greater than 0."
 
389
          return
 
390
        end
 
391
 
 
392
        begin
 
393
          # Require needed things for parallel running
 
394
          require 'thread'
 
395
          require 'timeout'
 
396
          @tasks = @files.dup # Array of filenames.
 
397
          @need_quit = false
 
398
          @dead_workers = []  # Array of dead workers.
 
399
          @warnings = []
 
400
          shutting_down = false
 
401
          rep = [] # FIXME: more good naming
 
402
 
 
403
          # Array of workers.
 
404
          @workers = @options[:parallel].times.map {
 
405
            worker = Worker.launch(@options[:ruby],@args)
 
406
            worker.hook(:dead) do |w,info|
 
407
              after_worker_quit w
 
408
              after_worker_down w, *info unless info.empty?
 
409
            end
 
410
            worker
 
411
          }
 
412
 
 
413
          # Thread: watchdog
 
414
          watchdog = Thread.new do
 
415
            while stat = Process.wait2
 
416
              break if @interrupt # Break when interrupt
 
417
              pid, stat = stat
 
418
              w = (@workers + @dead_workers).find{|x| pid == x.pid }.dup
 
419
              next unless w
 
420
              unless w.status == :quit
 
421
                # Worker down
 
422
                w.died(nil, !stat.signaled? && stat.exitstatus)
 
423
              end
 
424
            end
 
425
          end
 
426
 
 
427
          @workers_hash = Hash[@workers.map {|w| [w.io,w] }] # out-IO => worker
 
428
          @ios = @workers.map{|w| w.io } # Array of worker IOs
 
429
 
 
430
          while _io = IO.select(@ios)[0]
 
431
            break unless _io.each do |io|
 
432
              break if @need_quit
 
433
              worker = @workers_hash[io]
 
434
              case worker.read
 
435
              when /^okay$/
 
436
                worker.status = :running
 
437
                jobs_status
 
438
              when /^ready$/
 
439
                worker.status = :ready
 
440
                if @tasks.empty?
 
441
                  break unless @workers.find{|x| x.status == :running }
 
442
                else
 
443
                  worker.run(@tasks.shift, type)
 
444
                end
 
445
 
 
446
                jobs_status
 
447
              when /^done (.+?)$/
 
448
                r = Marshal.load($1.unpack("m")[0])
 
449
                result << r[0..1] unless r[0..1] == [nil,nil]
 
450
                rep    << {file: worker.real_file,
 
451
                           report: r[2], result: r[3], testcase: r[5]}
 
452
                $:.push(*r[4]).uniq!
 
453
              when /^p (.+?)$/
 
454
                del_jobs_status
 
455
                print $1.unpack("m")[0]
 
456
                jobs_status if @options[:job_status] == :replace
 
457
              when /^after (.+?)$/
 
458
                @warnings << Marshal.load($1.unpack("m")[0])
 
459
              when /^bye (.+?)$/
 
460
                after_worker_down worker, Marshal.load($1.unpack("m")[0])
 
461
              when /^bye$/
 
462
                if shutting_down
 
463
                  after_worker_quit worker
 
464
                else
 
465
                  after_worker_down worker
 
466
                end
 
467
              end
 
468
              break if @need_quit
 
469
            end
 
470
          end
 
471
        rescue Interrupt => e
 
472
          @interrupt = e
 
473
          return result
 
474
        ensure
 
475
          shutting_down = true
 
476
 
 
477
          watchdog.kill if watchdog
 
478
          if @interrupt
 
479
            @ios.select!{|x| @workers_hash[x].status == :running }
 
480
            while !@ios.empty? && (__io = IO.select(@ios,[],[],10))
 
481
                _io = __io[0]
 
482
                _io.each do |io|
 
483
                  worker = @workers_hash[io]
 
484
                  case worker.read
 
485
                  when /^done (.+?)$/
 
486
                    r = Marshal.load($1.unpack("m")[0])
 
487
                    result << r[0..1] unless r[0..1] == [nil,nil]
 
488
                    rep    << {file: worker.real_file,
 
489
                               report: r[2], result: r[3], testcase: r[5]}
 
490
                    $:.push(*r[4]).uniq!
 
491
                    @ios.delete(io)
 
492
                  end
 
493
                end
 
494
            end
 
495
          end
 
496
          @workers.each do |worker|
 
497
            begin
 
498
              timeout(1) do
 
499
                worker.puts "quit"
 
500
              end
 
501
            rescue Errno::EPIPE
 
502
            rescue Timeout::Error
 
503
            end
 
504
            worker.close
 
505
          end
 
506
          begin
 
507
            timeout(0.2*@workers.size) do
 
508
              Process.waitall
 
509
            end
 
510
          rescue Timeout::Error
 
511
            @workers.each do |worker|
 
512
              begin
 
513
                Process.kill(:KILL,worker.pid)
 
514
              rescue Errno::ESRCH; end
 
515
            end
 
516
          end
 
517
 
 
518
          if @interrupt || @options[:no_retry] || @need_quit
 
519
            rep.each do |r|
 
520
              report.push(*r[:report])
 
521
            end
 
522
            @errors   += rep.map{|x| x[:result][0] }.inject(:+)
 
523
            @failures += rep.map{|x| x[:result][1] }.inject(:+)
 
524
            @skips    += rep.map{|x| x[:result][2] }.inject(:+)
 
525
          else
 
526
            puts ""
 
527
            puts "Retrying..."
 
528
            puts ""
 
529
            rep.each do |r|
 
530
              if r[:testcase] && r[:file] && !r[:report].empty?
 
531
                require r[:file]
 
532
                _run_suite(eval(r[:testcase]),type)
 
533
              else
 
534
                report.push(*r[:report])
 
535
                @errors += r[:result][0]
 
536
                @failures += r[:result][1]
 
537
                @skips += r[:result][2]
 
538
              end
 
539
            end
 
540
          end
 
541
          if @warnings
 
542
            warn ""
 
543
            ary = []
 
544
            @warnings.reject! do |w|
 
545
              r = ary.include?(w[1].message)
 
546
              ary << w[1].message
 
547
              r
 
548
            end
 
549
            @warnings.each do |w|
 
550
              warn "#{w[0]}: #{w[1].message} (#{w[1].class})"
 
551
            end
 
552
            warn ""
 
553
          end
 
554
        end
 
555
      end
 
556
 
 
557
      def _run_suites suites, type
 
558
        @interrupt = nil
 
559
        result = []
 
560
        if @options[:parallel]
 
561
          _run_parallel suites, type, result
 
562
        else
 
563
          suites.each {|suite|
 
564
            begin
 
565
              result << _run_suite(suite, type)
 
566
            rescue Interrupt => e
 
567
              @interrupt = e
 
568
              break
 
569
            end
 
570
          }
 
571
        end
 
572
        report.reject!{|r| r.start_with? "Skipped:" } if @options[:hide_skip]
 
573
        result
 
574
      end
 
575
 
 
576
      # Overriding of MiniTest::Unit#puke
 
577
      def puke klass, meth, e
 
578
        # TODO:
 
579
        #   this overriding is for minitest feature that skip messages are
 
580
        #   hidden when not verbose (-v), note this is temporally.
 
581
        e = case e
 
582
            when MiniTest::Skip then
 
583
              @skips += 1
 
584
              "Skipped:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
 
585
            when MiniTest::Assertion then
 
586
              @failures += 1
 
587
              "Failure:\n#{meth}(#{klass}) [#{location e}]:\n#{e.message}\n"
 
588
            else
 
589
              @errors += 1
 
590
              bt = MiniTest::filter_backtrace(e.backtrace).join "\n    "
 
591
              "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
 
592
            end
 
593
        @report << e
 
594
        e[0, 1]
 
595
      end
 
596
 
 
597
      def status(*args)
 
598
        result = super
 
599
        raise @interrupt if @interrupt
 
600
        result
 
601
      end
 
602
    end
 
603
 
 
604
    class AutoRunner
 
605
      class Runner < Test::Unit::Runner
 
606
        include Test::Unit::RequireFiles
 
607
      end
 
608
 
 
609
      attr_accessor :to_run, :options
 
610
 
 
611
      def initialize(force_standalone = false, default_dir = nil, argv = ARGV)
 
612
        @runner = Runner.new do |files, options|
 
613
          options[:base_directory] ||= default_dir
 
614
          files << default_dir if files.empty? and default_dir
 
615
          @to_run = files
 
616
          yield self if block_given?
 
617
          files
 
618
        end
 
619
        Runner.runner = @runner
 
620
        @options = @runner.option_parser
 
621
        @argv = argv
 
622
      end
 
623
 
 
624
      def process_args(*args)
 
625
        @runner.process_args(*args)
 
626
        !@to_run.empty?
 
627
      end
 
628
 
 
629
      def run
 
630
        @runner.run(@argv) || true
 
631
      end
 
632
 
 
633
      def self.run(*args)
 
634
        new(*args).run
 
635
      end
62
636
    end
63
637
  end
64
638
end
65
639
 
66
 
MiniTest::Unit.autorun
 
640
Test::Unit::Runner.autorun