rio 0.3.1

data/test/tc/nolines.rb

@@ -0,0 +1,205 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+
+class TC_RIO_nolines < Test::Unit::TestCase
+  def tdir() rio(%w/qp nolines/) end
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  require 'extensions/symbol'
+  def smap(a) a.map( &:to_s ) end
+  def mkafile(*args)
+    file = rio(*args)
+    file < (0..1).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def mkalinesfile(n_lines,*args)
+    file = rio(*args)
+    file < (0...n_lines).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def setup
+    #$trace_states = true
+    @cwd = ::Dir.getwd
+    tdir.mkpath.chdir
+  end
+  def teardown
+    ::Dir.chdir @cwd
+  end
+
+  def test_symbol
+    rio('a').delete!.mkpath.chdir
+
+    file,lines = file_lines()
+
+    lines[1] = "\n"
+    lines[6] = "\n"
+    file < lines
+
+    exp = lines[0..0] + lines[2..5] + lines[7...8]
+    ans = file.chomp.nolines[:empty?]
+    assert_equal(exp.map(&:chomp),ans)
+
+    ans = file.nolines(:empty?).chomp.to_a
+    assert_equal(exp.map(&:chomp),ans)
+
+    file.close
+    rio('..').chdir
+  end
+  def file_lines(n_lines=8)
+    file = mkalinesfile(n_lines,'f1')
+    lines = file[]
+    (2..4).each do |n|
+      lines[n] = '#' + lines[n]
+    end
+    (0..3).each do |n|
+      lines[n].sub!(/f1/,'f2')
+    end
+    file < lines
+    [file,lines]
+  end
+  def test_basic
+    rio('a').delete!.mkpath.chdir
+    file,lines = file_lines()
+    exp = lines[1..1] + lines[5...8]
+
+    # iterate over the first line and comment lines
+    begin
+      f0 = file.dup
+      ans = f0.nolines[0,/^\s*#/]
+      assert_equal(exp,ans)
+    end
+
+    begin
+      f0 = file.dup
+      ans = f0.nolines[proc { |rec,rnum,rio| rnum == 0 || rec =~ /^\s*#/ }]
+      assert_equal(exp,ans)
+    end
+    begin
+      f0 = file.dup
+      
+      #$trace_states = true
+      exp0 = lines[0..1] + lines[5...8] 
+      ans = f0.nolines[/^\s*#/]
+      #p f0.cx
+      #$trace_states = false
+      assert_equal(exp0,ans)
+    end
+  end
+  def test_proc
+    file,lines = file_lines()
+    #p lines
+    exp1 = lines[4...8]
+    ans = file.lines[proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }]
+    assert_equal(exp1,ans)
+
+    exp2 = lines[2..4]
+    exp = exp1 - exp2
+    ans = file.lines(proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }).nolines[/^\s*#/]
+    assert_equal(exp,ans)
+
+    ans = file.nolines(/^\s*#/).lines[proc { |rec,rnum,ario| rec =~ /#{ario.filename}/ }]
+    assert_equal(exp,ans)
+  end
+
+  def test_ranges_ss
+#    $trace_states = true
+    lfile,lines = file_lines()
+
+    ans = rio('f1').nolines(2..4).lines[0..2]
+    exp = lines[6..6]
+
+    ans = rio('f1').norecords(0).records(0..2).norecords(2..4).records[6]
+    assert_equal(exp,ans)
+
+    ans = rio('f1').lines(0..2).nolines(0,2..4).lines[6]
+    assert_equal(exp,ans)
+    ans = rio('f1').nolines(0,2..4).lines[0..2,6]
+
+    assert_equal(lines[1..1]+lines[6..6],ans)
+
+
+    ans = rio('f1').nolines(0).lines(0..2).nolines(2..4).lines[6]
+    assert_equal(exp,ans)
+    ans = rio('f1').nolines(0).lines(0..2).nolines(2..4).lines[6]
+    assert_equal(exp,ans)
+    ans = rio('f1').records(0..2).norecords(0,2..4).records[6]
+    assert_equal(exp,ans)
+    ans = rio('f1').norecords(0,2..4).records[0..2,6]
+    assert_equal(lines[1..1]+lines[6..6],ans)
+
+    exp = lines[1..1] + lines[5..7]
+    ans = rio('f1').nolines(0,2..4).lines[0..2,6,/f1/]
+    assert_equal(exp,ans)
+
+
+    lfile.close
+    rio('..').chdir
+  end
+  def iter_tests(file,exp)
+    ans = file.clone.to_a
+    assert_equal(exp,ans)
+
+
+    ans = []
+    file.clone.each { |rec| ans << rec }
+    assert_equal(exp,ans)
+
+    ans = []
+    file.clone.each_record { |rec| ans << rec }
+    assert_equal(exp,ans)
+
+    ans = []
+    f = file.clone
+    while rec = f.getrec
+      ans << rec
+    end
+    assert_equal(exp,ans)
+
+    
+  end
+  def test_ranges
+#    $trace_states = true
+    lfile,lines = file_lines()
+
+    file = lfile.dup.nolines(2..4).lines(0..2)
+    exp = lines[0..1]
+    #p "HEE"
+#    breakpoint
+    iter_tests(file,exp)
+
+    file = lfile.dup.norecords(0).records(0..2).norecords(2..4).records(6)
+    exp = lines[6..6]
+    iter_tests(file,exp)
+
+    file = lfile.dup.lines(0..2).nolines(0,2..4).lines(6)
+    iter_tests(file,exp)
+
+    file = lfile.dup.nolines(0,2..4).lines(0..2,6)
+    iter_tests(file,lines[1..1]+lines[6..6])
+
+    file = lfile.dup.nolines(0).lines(0..2).nolines(2..4).lines(6)
+    iter_tests(file,exp)
+
+    file = lfile.dup.records(0..2).norecords(0,2..4).records(6)
+    iter_tests(file,exp)
+
+    file = lfile.dup.norecords(0,2..4).records(0..2,6)
+    iter_tests(file,lines[1..1]+lines[6..6])
+
+    exp = lines[1..1] + lines[5..7]
+    file = lfile.dup.nolines(0,2..4).lines(0..2,6,/f1/)
+    iter_tests(file,exp)
+
+
+    lfile.close
+    rio('..').chdir
+  end
+end

data/test/tc/noqae.rb

@@ -0,0 +1,873 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+require 'extensions/symbol'
+require 'tc/testcase'
+class TC_RIO_noqae < Test::Unit::TestCase
+  @@tdir = rio(%w/qp noqae/)
+  @@once = false
+  def initialize(*args)
+    super
+  end
+    
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map( &:to_s ) end
+  def setup
+    s_dir = ''
+    #$trace_states = true
+    unless @@once
+      @@once =  true
+
+      @@tdir.rmtree.mkpath.chdir do
+        rio('d0').mkpath.chdir {
+          rio('d2').mkpath
+          rio('d1').mkpath.chdir {
+            rio('d2').mkpath.chdir {
+              rio('d1').mkpath.chdir {
+                rio('f1') < (0..1).map { |i| "L#{i}:d0/d1/d2/d1/f1\n" }
+                rio('f2') < (0..1).map { |i| "L#{i}:d0/d1/d2/d1/f2\n" }
+              }
+              rio('f1') < (0..1).map { |i| "L#{i}:d0/d1/d2/f1\n" }
+            }
+          }
+          rio('f1') < (0..1).map { |i| "L#{i}:d0/f1\n" }
+          rio('f2') < (0..1).map { |i| "L#{i}:d0/f2\n" }
+          rio('x1').symlink('n1')
+          rio('x2').symlink('n2')
+          rio('f1').symlink('l1')
+          rio('f2').symlink('l2')
+          rio('d1').symlink('c1')
+          rio('d2').symlink('c2')
+        }
+
+        rio('d1').mkpath.chdir {
+          rio('d1').mkpath.chdir {
+            rio('f1') < (0..1).map { |i| "L#{i}:d1/d1/f1\n" }
+            rio('f2') < (0..1).map { |i| "L#{i}:d1/d1/f2\n" }
+          }
+          rio('d2').mkpath.chdir {
+            rio('d1').mkpath.chdir {
+              rio('f1') < (0..1).map { |i| "L#{i}:d1/d2/d1/f1\n" }
+              rio('f2') < (0..1).map { |i| "L#{i}:d1/d2/d1/f2\n" }
+            }
+            rio('d2').mkpath
+          }
+          rio('d3').mkpath.chdir {
+            rio('d1').mkpath.chdir {
+              rio('f1') < (0..1).map { |i| "L#{i}:d1/d3/d1/f1\n" }
+              rio('d1').mkpath
+            }
+            rio('f1') < (0..1).map { |i| "L#{i}:d1/d3/f1\n" }
+          }
+        }
+
+      end
+    end
+  end
+
+  def test_noqae_fs
+    return unless $supports_symlink
+    all = ['d0/d1','d0/d2','d0/c1','d0/c2','d0/f1','d0/f2','d0/n1','d0/n2','d0/l1','d0/l2']
+    rio('qp/noqae').chdir do
+      begin
+
+        begin
+          ans = []
+          rio('d0').each { |el| ans << el }
+          exp = all.dup
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').to_a
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').entries[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+      
+      begin
+        begin
+          ans = []
+          rio('d0').nodirs.each { |el| ans << el }
+          exp = all.reject { |el| el =~ /[cd]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').nofiles.each { |el| ans << el }
+          exp = all.reject { |el| el =~ /[fl]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d0').noentries.each { |el| ans << el }
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+
+      begin
+        begin
+          ans = []
+          rio('d0').nodirs.nofiles.each { |el| ans << el }
+          exp = all.reject { |el| el =~ /[cdfl]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles.nodirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs.nofiles[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').nodirs.files.each { |el| ans << el }
+          exp = all.select { |el| el =~ /[fl]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs.files[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').files.nodirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          exp = all.select { |el| el =~ /[n]\d$/ }
+          ans = []
+          rio('d0').entries.nofiles.nodirs.each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d0').entries.nofiles.nodirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').entries.nodirs.nofiles[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles.nodirs.entries[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles.nodirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          exp = []
+          ans = []
+          rio('d0').noentries.dirs.each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          rio('d0').noentries.files.each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d0').noentries.files[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries.dirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          exp = []
+          ans = []
+          rio('d0').noentries.each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+    end
+  end
+
+  def test_noqae_fs_de
+    return unless $supports_symlink
+    all = ['d0/d1','d0/d2','d0/c1','d0/c2','d0/f1','d0/f2','d0/n1','d0/n2','d0/l1','d0/l2']
+    wd = ::Dir.getwd
+    rio('qp/noqae').chdir
+    begin
+      begin
+        ans = []
+        rio('d0').dirs.each { |el| 
+          assert(el.directory?)
+        }
+        rio('d0').nodirs.each { |el| 
+          assert!(el.directory?)
+        }
+        rio('d0').nodirs('*').each { |el| 
+          assert(el.directory?)
+        }
+        rio('d0').files.each { |el| 
+          assert(el.file?)
+        }
+        rio('d0').nofiles.each { |el| 
+          assert!(el.file?)
+        }
+        rio('d0').nofiles('*').each { |el| 
+          assert(el.file?)
+        }
+        begin
+          exp = all.select { |el| el =~ /[lnc]\d\Z/ }
+          ans = []
+          rio('d0').entries(:symlink?).each { |el| 
+            assert(el.symlink?)
+            ans << el
+          }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          exp = all.select { |el| el =~ /[l]\d\Z/ }
+          ans = []
+          rio('d0').files(:symlink?).each { |el| 
+            assert(el.file?)
+            assert(el.symlink?)
+            ans << el
+          }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          exp = all.select { |el| el =~ /[c]\d\Z/ }
+          ans = []
+          rio('d0').dirs(:symlink?).each { |el| 
+            assert(el.directory?)
+            assert(el.symlink?)
+            ans << el
+          }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          exp = all.select { |el| el =~ /[df]\d\Z/ }
+          ans = []
+          rio('d0').noentries(:symlink?).each { |el| 
+            assert!(el.symlink?)
+            ans << el
+          }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          exp = all.select { |el| el =~ /[d]\d\Z/ }
+          ans = []
+          rio('d0').nodirs(:symlink?).each { |el| 
+            assert(el.directory?)
+            assert!(el.symlink?)
+            ans << el
+          }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          exp = all.select { |el| el =~ /[f]\d\Z/ }
+          ans = []
+          rio('d0').nofiles(:symlink?).each { |el| 
+            assert(el.file?)
+            assert!(el.symlink?)
+            ans << el
+          }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+    end
+    rio(wd).chdir
+  end
+  def test_noqae_fs_re
+    return unless $supports_symlink
+    all = ['d0/d1','d0/d2','d0/c1','d0/c2','d0/f1','d0/f2','d0/n1','d0/n2','d0/l1','d0/l2']
+    rio('qp/noqae').chdir do
+      begin
+
+        begin
+          ere = /1/
+          exp = all.reject { |el| el =~ ere }
+          ans = []
+          rio('d0').noentries(ere).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries(ere).to_a
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries[ere]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+      
+      begin
+        begin
+          dre = /1/
+          exp = all.select { |el| el =~ /[cd]2$/ }
+          ans = []
+          rio('d0').nodirs(dre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs[dre]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          dre = /1/
+          exp = all.select { |el| el =~ /[d]2$/ }
+          ans = []
+          rio('d0').nodirs(dre,:symlink?).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs[dre,:symlink?]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          fre = /2/
+          exp = all.select { |el| el =~ /[fl]1$/ }
+          ans = []
+          rio('d0').nofiles(fre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles[fre]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ere = /1/
+          exp = all.select { |el| el =~ /2$/ }
+          ans = []
+          rio('d0').noentries(ere).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries[ere]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+
+      begin
+        dre = /1/
+        fre = /2/
+        begin
+          exp = all.select { |el| el =~ /([cd]2|[fl]1)$/ }
+          ans = []
+          rio('d0').nodirs(dre).nofiles(fre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles(fre).nodirs[dre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs(dre).nofiles[fre]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          exp = all.select { |el| el =~ /([cd]2|[fl]2)$/ }
+          ans = []
+          rio('d0').nodirs(dre).files(fre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nodirs(dre).files[fre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').files(fre).nodirs[dre]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          exp = all.select { |el| el =~ /([cd]2|[fl]1|n[12])$/ }
+          ans = []
+          rio('d0').entries.nofiles(fre).nodirs(dre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d0').entries.nofiles(fre).nodirs[dre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').entries.nodirs(dre).nofiles[fre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles(fre).nodirs(dre).entries[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ere = /1/
+          exp = all.select { |el| el =~ /([cd]2|[fl]1|n1)$/ }
+          ans = []
+          rio('d0').entries(ere).nofiles(fre).nodirs(dre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d0').entries(ere).nofiles(fre).nodirs[dre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').entries(ere).nodirs(dre).nofiles[fre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles(fre).nodirs(dre).entries[ere]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ere = /1/
+          dre = /c/
+          fre = /f/
+          exp = all.select { |el| el =~ /(d2|l2)$/ }
+          ans = []
+          rio('d0').noentries(ere).nofiles(fre).nodirs(dre).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d0').noentries(ere).nofiles(fre).nodirs[dre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries(ere).nodirs(dre).nofiles[fre]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').nofiles(fre).nodirs(dre).noentries[ere]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          exp = []
+          ans = []
+          rio('d0').noentries.dirs.each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          rio('d0').noentries.files.each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d0').noentries.files[]
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries.dirs[]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ere = /1/
+          exp = all.select { |el| el =~ /2$/ }
+          ans = []
+          rio('d0').noentries(ere).each { |el| ans << el }
+          assert_equal(exp.sort,smap(ans).sort)
+          ans = rio('d0').noentries[ere]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+    end
+  end
+
+  def ztest_noqae_fs_re
+    all = ['d0/d1','d0/d2','d0/c1','d0/c2','d0/f1','d0/f2','d0/n1','d0/n2','d0/l1','d0/l2']
+    rio('qp/noqae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').nofiles(/2/).each { |el| ans << el }
+          exp = all.reject { |el| el =~ /[fl]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').nofiles('*2').each { |el| ans << el }
+          exp = ['d0/f1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+      
+      begin
+        begin
+          ans = []
+          rio('d0').nofiles.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').nodirs(/2/).each { |el| ans << el }
+          exp = ['d0/d1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').nodirs('*2').each { |el| ans << el }
+          exp = ['d0/d1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+      begin
+        begin
+          ans = []
+          rio('d0').nofiles.dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          ans = []
+          rio('d0').nofiles.dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          ans = []
+          rio('d0').nofiles.dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          ans = []
+          rio('d0').nofiles.dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/f1','d0/f2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+
+        
+      begin
+        begin
+          ans = []
+          rio('d0').files(/1/).dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/f1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files.dirs(/1/).each { |el| ans << el }
+          exp = ['d0/d1','d0/f1','d0/f2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files(/1/).dirs(/1/).each { |el| ans << el }
+          exp = ['d0/d1','d0/f1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+  def ztest_noqae_fs_lines 
+    rio('qp/noqae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').files.each { |f|
+            f.each { |el|
+              ans << el 
+            }
+          }
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d0').files.lines.each { |el| ans << el }
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines.files.each { |el| ans << el }
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files.lines(/L1/).each { |el| ans << el }
+          exp = ["L1:d0/f1\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines(/L1/).files.each { |el| ans << el }
+          exp = ["L1:d0/f1\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines.each { |el| ans << el }
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines(/L1/).each { |el| ans << el }
+          exp = ["L1:d0/f1\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+
+  def ztest_noqae_fs_lines_ss
+    rio('qp/noqae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').files.each { |f|
+            f.each { |el|
+              ans << el 
+            }
+          }
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = rio('d0').files.lines[]
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines.files[]
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').files.lines[/L1/]
+          exp = ["L1:d0/f1\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines(/L1/).files[]
+          exp = ["L1:d0/f1\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines[]
+          exp = ["L0:d0/f1\n","L1:d0/f1\n","L0:d0/f2\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines[/L1/]
+          exp = ["L1:d0/f1\n","L1:d0/f2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+
+  def ztest_noqae_chomp 
+    rio('qp/noqae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0/f1').each { |el|
+            ans << el 
+          }
+          exp = ["L0:d0/f1\n","L1:d0/f1\n"]
+          assert_equal(exp,ans)
+        end
+        
+        begin
+          ans = []
+          rio('d0/f1').chomp.each { |el|
+            ans << el 
+          }
+          exp = ["L0:d0/f1","L1:d0/f1"]
+          assert_equal(exp,ans)
+        end
+        
+      end
+    end
+  end
+
+  def ztest_noqae_fs_nest
+    ds = ['d1/d1','d1/d2','d1/d1/f1','d1/d1/f2','d1/d2/d1','d1/d2/d1/f1','d1/d2/d1/f2','d1/d2/d2',
+          'd1/d3','d1/d3/d1','d1/d3/f1','d1/d3/d1/f1','d1/d3/d1/d1']
+    rio('qp/noqae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/.\d$| }
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.dirs.each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/d\d$| }
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.dirs(/1/).each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/d1$| }
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.all.dirs.each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/| && el =~ %r|d\d$|}
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.all.dirs(/1/).each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/| && el =~ %r|d1$|}
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+        
+
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.files.each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/q\d$| }
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.files(/1/).each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/f1$| }
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.all.files.each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/| && el =~ %r|q\d$|}
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d1').dirs.each { |dir|
+            dir.all.files(/1/).each { |ent| 
+              ans << ent 
+            }
+          }
+          exp = ds.select { |el| el =~ %r|^d1/d\d/| && el =~ %r|f1$|}
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+
+      end
+    end
+  end
+
+  def ztest_noqae_fs_all
+    ds = ['d0/d1','d0/d2','d0/f1','d0/f2','d0/d1/d2','d0/d1/d2/d1','d0/d1/d2/f1','d0/d1/d2/d1/f1','d0/d1/d2/d1/f2']
+    rio('qp/noqae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').all.each { |el| ans << el }
+          exp = ds.dup
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+
+      begin
+        begin
+          ans = []
+          rio('d0').all.files.dirs.each { |el| ans << el }
+          exp = ds.select { |el| el =~ /[qd]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').all.files(/1/).dirs.each { |el| ans << el }
+          exp = ds.select { |el| el =~ /(d\d|f1)$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').all.files.dirs(/1/).each { |el| ans << el }
+          exp = ds.select { |el| el =~ /(q\d|d1)$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').all.files(/1/).dirs(/1/).each { |el| ans << el }
+          exp = ds.select { |el| el =~ /[qd]1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+
+      begin
+        begin
+          ans = []
+          rio('d0').all.files.each { |el| ans << el }
+          exp = ds.select { |el| el =~ /q\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').all.files(/1/).each { |el| ans << el }
+          exp = ds.select { |el| el =~ /f1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').all.files('*1').each { |el| ans << el }
+          exp = ds.select { |el| el =~ /f1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+
+      begin
+        begin
+          ans = []
+          rio('d0').all.dirs.each { |el| ans << el }
+          exp = ds.reject { |el| el =~ /q\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d0').all.dirs(/1/).each { |el| ans << el }
+          exp = ds.select { |el| el =~ /d1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d0').all.dirs('*1').each { |el| ans << el }
+          exp = ds.select { |el| el =~ /d1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+end