← Back to branch summary

~ubuntu-branches/ubuntu/karmic/libcairo-ruby/karmic

« back to all changes in this revision

Viewing changes to test-unit/lib/test/unit/autorunner.rb

  • Committer: Bazaar Package Importer
  • Author(s): Paul van Tilburg, Gunnar Wolf, Paul van Tilburg
  • Date: 2009-05-05 12:14:31 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20090505121431-n803uyjz51je38l0
Tags: 1.8.0-1
[ Gunnar Wolf ]
* Changed section to Ruby as per ftp-masters' request

[ Paul van Tilburg ]
* New upstream release.
* debian/patches:
  - Dropped patch 01_fix-st.h-ruby1.9-paths: fixed by upstream. 
* debian/control:
  - Bumped standards version to 3.8.1; no changes required.
  - Added ${misc:Depends} to the depends of libcairo-ruby (binary).

Show diffs side-by-side

added added

removed removed

Lines of Context:
test-unit/lib/test/unit/autorunner.rb
 
1
require 'test/unit'
 
2
require 'optparse'
 
3
 
 
4
module Test
 
5
  module Unit
 
6
    class AutoRunner
 
7
      RUNNERS = {}
 
8
      COLLECTORS = {}
 
9
      ADDITIONAL_OPTIONS = []
 
10
 
 
11
      class << self
 
12
        def register_runner(id, runner_builder=Proc.new)
 
13
          RUNNERS[id] = runner_builder
 
14
        end
 
15
 
 
16
        def register_collector(id, collector_builder=Proc.new)
 
17
          COLLECTORS[id] = collector_builder
 
18
        end
 
19
 
 
20
        def setup_option(option_builder=Proc.new)
 
21
          ADDITIONAL_OPTIONS << option_builder
 
22
        end
 
23
      end
 
24
 
 
25
      def self.run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
 
26
        r = new(force_standalone || standalone?, &block)
 
27
        r.base = default_dir
 
28
        r.process_args(argv)
 
29
        r.run
 
30
      end
 
31
      
 
32
      def self.standalone?
 
33
        return false unless("-e" == $0)
 
34
        ObjectSpace.each_object(Class) do |klass|
 
35
          return false if(klass < TestCase)
 
36
        end
 
37
        true
 
38
      end
 
39
 
 
40
      register_collector(:descendant) do |auto_runner|
 
41
        require 'test/unit/collector/descendant'
 
42
        collector = Collector::Descendant.new
 
43
        collector.filter = auto_runner.filters
 
44
        collector.collect($0.sub(/\.rb\Z/, ''))
 
45
      end
 
46
 
 
47
      register_collector(:load) do |auto_runner|
 
48
        require 'test/unit/collector/load'
 
49
        collector = Collector::Load.new
 
50
        collector.patterns.concat(auto_runner.pattern) if auto_runner.pattern
 
51
        collector.excludes.concat(auto_runner.exclude) if auto_runner.exclude
 
52
        collector.base = auto_runner.base
 
53
        collector.filter = auto_runner.filters
 
54
        collector.collect(*auto_runner.to_run)
 
55
      end
 
56
 
 
57
      # deprecated
 
58
      register_collector(:object_space) do |auto_runner|
 
59
        require 'test/unit/collector/objectspace'
 
60
        c = Collector::ObjectSpace.new
 
61
        c.filter = auto_runner.filters
 
62
        c.collect($0.sub(/\.rb\Z/, ''))
 
63
      end
 
64
 
 
65
      # deprecated
 
66
      register_collector(:dir) do |auto_runner|
 
67
        require 'test/unit/collector/dir'
 
68
        c = Collector::Dir.new
 
69
        c.filter = auto_runner.filters
 
70
        c.pattern.concat(auto_runner.pattern) if auto_runner.pattern
 
71
        c.exclude.concat(auto_runner.exclude) if auto_runner.exclude
 
72
        c.base = auto_runner.base
 
73
        $:.push(auto_runner.base) if auto_runner.base
 
74
        c.collect(*(auto_runner.to_run.empty? ? ['.'] : auto_runner.to_run))
 
75
      end
 
76
 
 
77
      attr_reader :suite, :runner_options
 
78
      attr_accessor :filters, :to_run, :pattern, :exclude, :base, :workdir
 
79
      attr_writer :runner, :collector
 
80
 
 
81
      def initialize(standalone)
 
82
        Unit.run = true
 
83
        @standalone = standalone
 
84
        @runner = default_runner
 
85
        @collector = default_collector
 
86
        @filters = []
 
87
        @to_run = []
 
88
        @runner_options = {}
 
89
        @workdir = nil
 
90
        yield(self) if block_given?
 
91
      end
 
92
 
 
93
      def process_args(args = ARGV)
 
94
        begin
 
95
          options.order!(args) {|arg| @to_run << arg}
 
96
        rescue OptionParser::ParseError => e
 
97
          puts e
 
98
          puts options
 
99
          $! = nil
 
100
          abort
 
101
        else
 
102
          @filters << proc{false} unless(@filters.empty?)
 
103
        end
 
104
        not @to_run.empty?
 
105
      end
 
106
 
 
107
      def options
 
108
        @options ||= OptionParser.new do |o|
 
109
          o.banner = "Test::Unit automatic runner."
 
110
          o.banner << "\nUsage: #{$0} [options] [-- untouched arguments]"
 
111
 
 
112
          o.on
 
113
          o.on('-r', '--runner=RUNNER', RUNNERS,
 
114
               "Use the given RUNNER.",
 
115
               "(" + keyword_display(RUNNERS) + ")") do |r|
 
116
            @runner = r
 
117
          end
 
118
 
 
119
          if(@standalone)
 
120
            o.on('-b', '--basedir=DIR', "Base directory of test suites.") do |b|
 
121
              @base = b
 
122
            end
 
123
 
 
124
            o.on('-w', '--workdir=DIR', "Working directory to run tests.") do |w|
 
125
              @workdir = w
 
126
            end
 
127
 
 
128
            o.on('-a', '--add=TORUN', Array,
 
129
                 "Add TORUN to the list of things to run;",
 
130
                 "can be a file or a directory.") do |a|
 
131
              @to_run.concat(a)
 
132
            end
 
133
 
 
134
            @pattern = []
 
135
            o.on('-p', '--pattern=PATTERN', Regexp,
 
136
                 "Match files to collect against PATTERN.") do |e|
 
137
              @pattern << e
 
138
            end
 
139
 
 
140
            @exclude = []
 
141
            o.on('-x', '--exclude=PATTERN', Regexp,
 
142
                 "Ignore files to collect against PATTERN.") do |e|
 
143
              @exclude << e
 
144
            end
 
145
          end
 
146
 
 
147
          o.on('-n', '--name=NAME', String,
 
148
               "Runs tests matching NAME.",
 
149
               "(patterns may be used).") do |n|
 
150
            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
 
151
            case n
 
152
            when Regexp
 
153
              @filters << proc{|t| n =~ t.method_name ? true : nil}
 
154
            else
 
155
              @filters << proc{|t| n == t.method_name ? true : nil}
 
156
            end
 
157
          end
 
158
 
 
159
          o.on('-t', '--testcase=TESTCASE', String,
 
160
               "Runs tests in TestCases matching TESTCASE.",
 
161
               "(patterns may be used).") do |n|
 
162
            n = (%r{\A/(.*)/\Z} =~ n ? Regexp.new($1) : n)
 
163
            case n
 
164
            when Regexp
 
165
              @filters << proc{|t| n =~ t.class.name ? true : nil}
 
166
            else
 
167
              @filters << proc{|t| n == t.class.name ? true : nil}
 
168
            end
 
169
          end
 
170
 
 
171
          priority_filter = Proc.new do |test|
 
172
            if @filters.size > 2
 
173
              nil
 
174
            else
 
175
              Priority::Checker.new(test).need_to_run? or nil
 
176
            end
 
177
          end
 
178
          o.on("--[no-]priority-mode",
 
179
               "Runs some tests based on their priority.") do |priority_mode|
 
180
            if priority_mode
 
181
              @filters |= [priority_filter]
 
182
            else
 
183
              @filters -= [priority_filter]
 
184
            end
 
185
          end
 
186
 
 
187
          o.on('-I', "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
 
188
               "Appends directory list to $LOAD_PATH.") do |dirs|
 
189
            $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
 
190
          end
 
191
 
 
192
          ADDITIONAL_OPTIONS.each do |option_builder|
 
193
            option_builder.call(self, o)
 
194
          end
 
195
 
 
196
          o.on('--',
 
197
               "Stop processing options so that the",
 
198
               "remaining options will be passed to the",
 
199
               "test."){o.terminate}
 
200
 
 
201
          o.on('-h', '--help', 'Display this help.'){puts o; exit}
 
202
 
 
203
          o.on_tail
 
204
          o.on_tail('Deprecated options:')
 
205
 
 
206
          o.on_tail('--console', 'Console runner (use --runner).') do
 
207
            warn("Deprecated option (--console).")
 
208
            @runner = RUNNERS[:console]
 
209
          end
 
210
 
 
211
          if RUNNERS[:fox]
 
212
            o.on_tail('--fox', 'Fox runner (use --runner).') do
 
213
              warn("Deprecated option (--fox).")
 
214
              @runner = RUNNERS[:fox]
 
215
            end
 
216
          end
 
217
 
 
218
          o.on_tail
 
219
        end
 
220
      end
 
221
 
 
222
      def keyword_display(array)
 
223
        list = array.collect {|e, *| e.to_s}
 
224
        Array === array or list.sort!
 
225
        list.collect {|e| e.sub(/^(.)([A-Za-z]+)(?=\w*$)/, '\\1[\\2]')}.join(", ")
 
226
      end
 
227
 
 
228
      def run
 
229
        suite = @collector[self]
 
230
        return false if suite.nil?
 
231
        runner = @runner[self]
 
232
        return false if runner.nil?
 
233
        Dir.chdir(@workdir) if @workdir
 
234
        runner.run(suite, @runner_options).passed?
 
235
      end
 
236
 
 
237
      private
 
238
      def default_runner
 
239
        if ENV["EMACS"] == "t"
 
240
          RUNNERS[:emacs]
 
241
        else
 
242
          RUNNERS[:console]
 
243
        end
 
244
      end
 
245
 
 
246
      def default_collector
 
247
        COLLECTORS[@standalone ? :load : :descendant]
 
248
      end
 
249
    end
 
250
  end
 
251
end
 
252
 
 
253
require 'test/unit/runner/console'
 
254
require 'test/unit/runner/emacs'