← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.8/intrepid-updates

« back to all changes in this revision

Viewing changes to test/testunit/collector/test_dir.rb

  • Committer: Bazaar Package Importer
  • Author(s): akira yamada
  • Date: 2007-03-13 22:11:58 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20070313221158-h3oql37brlaf2go2
Tags: 1.8.6-1
http://bugs.debian.org/410018
* new upstream version, 1.8.6.
* libruby1.8 conflicts with libopenssl-ruby1.8 (< 1.8.6) (closes: #410018)
* changed packaging style to cdbs from dbs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/testunit/collector/test_dir.rb
 
1
require 'test/unit'
 
2
require 'test/unit/collector/dir'
 
3
require 'pp'
 
4
 
 
5
module Test
 
6
  module Unit
 
7
    module Collector
 
8
      class TestDir < TestCase
 
9
        class FileSystem
 
10
          class Directory
 
11
            def initialize(name, fs, parent=self, &block)
 
12
              @name = name
 
13
              @fs = fs
 
14
              @parent = parent
 
15
              @contents = {'.' => self, '..' => parent}
 
16
              instance_eval(&block) if(block)
 
17
            end
 
18
            
 
19
            def file(name, contents)
 
20
              @contents[name] = contents
 
21
            end
 
22
 
 
23
            def dir(name, &block)
 
24
              @contents[name] = self.class.new(name, @fs, self, &block)
 
25
            end
 
26
 
 
27
            def entries
 
28
              @contents.keys
 
29
            end
 
30
 
 
31
            def directory?(name)
 
32
              return true if(name.nil? || name.empty?)
 
33
              return false unless(@contents.include?(name))
 
34
              @contents[name].kind_of?(self.class)
 
35
            end
 
36
 
 
37
            def file?(name)
 
38
              return false unless(@contents.include?(name))
 
39
              !directory?(name)
 
40
            end
 
41
 
 
42
            def exist?(name)
 
43
              @contents.include?(name)
 
44
            end
 
45
 
 
46
            def [](name)
 
47
              raise Errno::ENOENT, name unless(@contents.include?(name))
 
48
              @contents[name]
 
49
            end
 
50
 
 
51
            def path_to(name=nil)
 
52
              if(!name)
 
53
                @parent.path_to(@name)
 
54
              elsif(@parent == self)
 
55
                @fs.join('/', name)
 
56
              else
 
57
                @fs.join(@parent.path_to(@name), name)
 
58
              end
 
59
            end
 
60
          end
 
61
 
 
62
          class ObjectSpace
 
63
            def initialize
 
64
              @objects = []
 
65
            end
 
66
 
 
67
            def each_object(klass, &block)
 
68
              @objects.find_all{|o| o.kind_of?(klass)}.each(&block)
 
69
            end
 
70
 
 
71
            def <<(object)
 
72
              @objects << object
 
73
            end
 
74
          end
 
75
 
 
76
          attr_reader :object_space
 
77
          
 
78
          def initialize(&block)
 
79
            @root = Directory.new('/', self, &block)
 
80
            @pwd = @root
 
81
            @object_space = ObjectSpace.new
 
82
            @required = []
 
83
          end
 
84
 
 
85
          def entries(dir)
 
86
            e = find(dir)
 
87
            require_directory(dir)
 
88
            e.entries
 
89
          end
 
90
 
 
91
          def directory?(name)
 
92
            return true if (base = basename(name)) == '/'
 
93
            e = find(dirname(name))
 
94
            return false unless(e)
 
95
            e.directory?(base)
 
96
          end
 
97
 
 
98
          def find(path)
 
99
            if(/\A\// =~ path)
 
100
              thing = @root
 
101
            else
 
102
              thing = @pwd
 
103
            end
 
104
            path.scan(/[^\/]+/) do |e|
 
105
              break thing = false unless(thing.kind_of?(Directory))
 
106
              thing = thing[e]
 
107
            end
 
108
            thing
 
109
          end
 
110
 
 
111
          def dirname(name)
 
112
            if (name = name.tr_s('/', '/')) == '/'
 
113
              name
 
114
            else
 
115
              name[%r"\A.+(?=/[^/]+/?\z)|\A/"] || "."
 
116
            end
 
117
          end
 
118
 
 
119
          def basename(name)
 
120
            name[%r"(\A/|[^/]+)/*\z", 1]
 
121
          end
 
122
 
 
123
          def split(name)
 
124
            [dirname(name), basename(name)]
 
125
          end
 
126
 
 
127
          def join(*parts)
 
128
            parts.join('/').gsub(%r{/+}, '/')
 
129
          end
 
130
 
 
131
          def file?(name)
 
132
            e = find(dirname(name))
 
133
            return false unless(e)
 
134
            e.file?(basename(name))
 
135
          end
 
136
 
 
137
          def pwd
 
138
            @pwd.path_to
 
139
          end
 
140
 
 
141
          def chdir(to)
 
142
            e = find(to)
 
143
            require_directory(to)
 
144
            @pwd = e
 
145
          end
 
146
 
 
147
          def expand_path(path, base = nil)
 
148
            until /\A\// =~ path
 
149
              base ||= pwd
 
150
              path = join(base, path)
 
151
              base = nil
 
152
            end
 
153
            path.gsub!(%r"(?:/\.)+(?=/)", '')
 
154
            nil while path.sub!(%r"/(?!\.\./)[^/]+/\.\.(?=/)", '')
 
155
            path.sub!(%r"\A(?:/\.\.)+(?=/)", '')
 
156
            path.sub!(%r"(?:\A(/)|/)\.\.?\z", '\1')
 
157
            path
 
158
          end
 
159
 
 
160
          def require_directory(path)
 
161
            raise Errno::ENOTDIR, path unless(directory?(path))
 
162
          end
 
163
 
 
164
          def require(file)
 
165
            return false if(@required.include?(file))
 
166
            begin
 
167
              e = find(file)
 
168
            rescue Errno::ENOENT => e
 
169
              if(/\.rb\Z/ =~ file)
 
170
                raise LoadError, file
 
171
              end
 
172
              e = find(file + '.rb')
 
173
            end
 
174
            @required << file
 
175
            @object_space << e
 
176
            true
 
177
          rescue Errno::ENOENT
 
178
            raise LoadError, file
 
179
          end
 
180
        end
 
181
 
 
182
        def test_dir
 
183
          inner_dir = nil
 
184
          dirs = FileSystem::Directory.new('/', nil) do
 
185
            file 'a', nil
 
186
            inner_dir = dir 'b'
 
187
          end
 
188
          assert_equal(inner_dir, dirs['b'])
 
189
        end
 
190
 
 
191
        def test_fs
 
192
          fs = FileSystem.new do
 
193
            file 'a', nil
 
194
            dir 'b'
 
195
          end
 
196
          assert_equal(['.', '..', 'a', 'b'].sort, fs.entries('/').sort)
 
197
          assert(fs.directory?('/'))
 
198
          assert(!fs.directory?('/a'))
 
199
          assert(!fs.directory?('/bogus'))
 
200
          assert(fs.file?('/a'))
 
201
          assert(!fs.file?('/'))
 
202
          assert(!fs.file?('/bogus'))
 
203
          assert(fs.directory?('/b'))
 
204
          assert(fs.file?('a'))
 
205
          assert(fs.directory?('b'))
 
206
        end
 
207
 
 
208
        def test_fs_sub
 
209
          fs = FileSystem.new do
 
210
            dir 'a' do
 
211
              file 'b', nil
 
212
              dir 'c' do
 
213
                file 'd', nil
 
214
              end
 
215
            end
 
216
          end
 
217
          assert(fs.file?('/a/b'))
 
218
          assert(!fs.file?('/a/b/c/d'))
 
219
          assert(fs.file?('/a/c/d'))
 
220
        end
 
221
 
 
222
        def test_fs_pwd
 
223
          fs = FileSystem.new do
 
224
            file 'a', nil
 
225
            dir 'b' do
 
226
              file 'c', nil
 
227
              dir 'd' do
 
228
                file 'e', nil
 
229
              end
 
230
            end
 
231
          end
 
232
          assert_equal('/', fs.pwd)
 
233
          assert_raises(Errno::ENOENT) do
 
234
            fs.chdir('bogus')
 
235
          end
 
236
          assert_raises(Errno::ENOTDIR) do
 
237
            fs.chdir('a')
 
238
          end
 
239
          fs.chdir('b')
 
240
          assert_equal('/b', fs.pwd)
 
241
          fs.chdir('d')
 
242
          assert_equal('/b/d', fs.pwd)
 
243
          fs.chdir('..')
 
244
          assert_equal('/b', fs.pwd)
 
245
          fs.chdir('..')
 
246
          assert_equal('/', fs.pwd)
 
247
        end
 
248
 
 
249
        def test_fs_entries
 
250
          fs = FileSystem.new do
 
251
            file 'a', nil
 
252
            dir 'b' do
 
253
              file 'c', nil
 
254
              file 'd', nil
 
255
            end
 
256
            file 'e', nil
 
257
            dir 'f' do
 
258
              file 'g', nil
 
259
              dir 'h' do
 
260
                file 'i', nil
 
261
              end
 
262
            end
 
263
          end
 
264
          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('/').sort)
 
265
          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('.').sort)
 
266
          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('b/..').sort)
 
267
          assert_equal(['.', '..', 'c', 'd'], fs.entries('b').sort)
 
268
          assert_raises(Errno::ENOENT) do
 
269
            fs.entries('z')
 
270
          end
 
271
          assert_raises(Errno::ENOTDIR) do
 
272
            fs.entries('a')
 
273
          end
 
274
          fs.chdir('f')
 
275
          assert_equal(['.', '..', 'i'], fs.entries('h').sort)
 
276
        end
 
277
 
 
278
        class TestClass1
 
279
        end
 
280
        class TestClass2
 
281
        end
 
282
        def test_fs_require
 
283
          fs = FileSystem.new do
 
284
            file 'test_class1.rb', TestClass1
 
285
            dir 'dir' do
 
286
              file 'test_class2.rb', TestClass2
 
287
            end
 
288
          end
 
289
          c = []
 
290
          fs.object_space.each_object(Class) do |o|
 
291
            c << o
 
292
          end
 
293
          assert_equal([], c)
 
294
 
 
295
          assert_raises(LoadError) do
 
296
            fs.require('bogus')
 
297
          end
 
298
          
 
299
          assert(fs.require('test_class1.rb'))
 
300
          assert(!fs.require('test_class1.rb'))
 
301
          c = []
 
302
          fs.object_space.each_object(Class) do |o|
 
303
            c << o
 
304
          end
 
305
          assert_equal([TestClass1], c)
 
306
 
 
307
          fs.require('dir/test_class2')
 
308
          c = []
 
309
          fs.object_space.each_object(Class) do |o|
 
310
            c << o
 
311
          end
 
312
          assert_equal([TestClass1, TestClass2], c)
 
313
 
 
314
          c = []
 
315
          fs.object_space.each_object(Time) do |o|
 
316
            c << o
 
317
          end
 
318
          assert_equal([], c)
 
319
        end
 
320
 
 
321
        def setup
 
322
          @t1 = t1 = create_test(1)
 
323
          @t2 = t2 = create_test(2)
 
324
          @t3 = t3 = create_test(3)
 
325
          @t4 = t4 = create_test(4)
 
326
          @t5 = t5 = create_test(5)
 
327
          @t6 = t6 = create_test(6)
 
328
          fs = FileSystem.new do
 
329
            file 'test_1.rb', t1
 
330
            file 'test_2.rb', t2
 
331
            dir 'd1' do
 
332
              file 'test_3.rb', t3
 
333
            end
 
334
            file 't4.rb', t4
 
335
            dir 'd2' do
 
336
              file 'test_5', t5
 
337
              file 'test_6.rb', Time
 
338
            end
 
339
            file 't6.rb', t6
 
340
          end
 
341
          fs.require('t6')
 
342
          @c = Dir.new(fs, fs, fs.object_space, fs)
 
343
        end
 
344
 
 
345
        def create_test(name)
 
346
          t = Class.new(TestCase)
 
347
          t.class_eval <<-EOC
 
348
            def self.name
 
349
              "T\#{#{name}}"
 
350
            end
 
351
            def test_#{name}a
 
352
            end
 
353
            def test_#{name}b
 
354
            end
 
355
          EOC
 
356
          t
 
357
        end
 
358
 
 
359
        def test_simple_collect
 
360
          expected = TestSuite.new('d1')
 
361
          expected << (@t3.suite)
 
362
          assert_equal(expected, @c.collect('d1'))
 
363
        end
 
364
 
 
365
        def test_multilevel_collect
 
366
          expected = TestSuite.new('.')
 
367
          expected << @t1.suite << @t2.suite
 
368
          expected << (TestSuite.new('d1') << @t3.suite)
 
369
          assert_equal(expected, @c.collect)
 
370
        end
 
371
 
 
372
        def test_collect_file
 
373
          expected = TestSuite.new('test_1.rb')
 
374
          expected << @t1.suite
 
375
          assert_equal(expected, @c.collect('test_1.rb'))
 
376
          
 
377
          expected = TestSuite.new('t4.rb')
 
378
          expected << @t4.suite
 
379
          assert_equal(expected, @c.collect('t4.rb'))
 
380
        end
 
381
 
 
382
        def test_nil_pattern
 
383
          expected = TestSuite.new('d2')
 
384
          expected << @t5.suite
 
385
          @c.pattern.clear
 
386
          assert_equal(expected, @c.collect('d2'))
 
387
        end
 
388
 
 
389
        def test_filtering
 
390
          expected = TestSuite.new('.')
 
391
          expected << @t1.suite
 
392
          @c.filter = proc{|t| t.method_name == 'test_1a' || t.method_name == 'test_1b'}
 
393
          assert_equal(expected, @c.collect)
 
394
        end
 
395
 
 
396
        def test_collect_multi
 
397
          expected = TestSuite.new('[d1, d2]')
 
398
          expected << (TestSuite.new('d1') << @t3.suite)
 
399
          expected << (TestSuite.new('d2') << @t5.suite)
 
400
          @c.pattern.replace([/\btest_/])
 
401
          assert_equal(expected, @c.collect('d1', 'd2'))
 
402
        end
 
403
      end
 
404
    end
 
405
  end
 
406
end