wishdev-rio 0.4.3.1

data/test/tc/pathop.rb

@@ -0,0 +1,60 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+
+class TC_pathop < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('d0').rmtree.mkpath
+    rio('d0/d2').rmtree.mkpath
+    rio('d0/d3').rmtree.mkpath
+    rio('d0/d4').rmtree.mkpath
+    rio('d0/d2/d3').rmtree.mkpath
+    rio('d0/d2/d5').rmtree.mkpath
+    rio('d0/d3/d6').rmtree.mkpath
+    rio('d1').rmtree.mkpath
+    rio('d1/d8').rmtree.mkpath
+    make_lines_file(1,'d1/f0')
+    make_lines_file(2,'d1/f1')
+    make_lines_file(1,'d0/f0')
+    make_lines_file(2,'d0/f1')
+    make_lines_file(1,'d0/d2/f0')
+    make_lines_file(2,'d0/d2/f1')
+    make_lines_file(1,'d0/d3/d6/f0')
+    make_lines_file(2,'d0/d3/d6/f1')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @d0 = rio('d0')
+    @d1 = rio('d1')
+    @d2 = @d0/'d2'
+    @f0 = @d0/'f0'
+    @f1 = @d0/'f1'
+    @f2 = @d0/'d2'/'f2'
+    @f3 = @d0/'d2'/'f3'
+
+  end
+  def test_p1
+    src = rio(@d1)
+    dst = []
+    puts @f3
+    p File.split('/qe/pi/')
+  end
+  def test_p2
+    p1 = rio('p1')
+    p2 = rio('p2')
+    p3 = p1.join(p2)
+    puts p1,p3
+    p3 = p1.join!(p2)
+    puts p1,p3
+
+  end
+end

data/test/tc/paths.rb

@@ -0,0 +1,145 @@
+#!/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_paths < Test::Unit::TestCase
+  def smap(a) a.map { |el| el.to_s } end
+  def pmap(a)
+    a.sort
+  end
+  def gmap(io)
+    smap(io.to_a).sort
+  end
+
+  def test_paths
+    s_dir = ''
+    tdir = rio(%w/qp test_paths/)
+    tdir.rmtree.mkpath.chdir {
+      rio(%w/dir0 dir00 dir000/).mkpath
+      rio(%w/dir1 dir10 dir000/).mkpath
+      rio(%w/dir1 dir10 dir100/).mkpath
+      rio(%w/dir1 dir11/).mkpath
+      rio(%w/dir1 f0.txt/).touch
+      rio(%w/dir1 dir10 f0.txt/).touch
+      rio(%w/dir1 dir10 f1.txt/).touch
+      rio(%w/dir1 dir10 f2.emp/).touch
+      rio(%w/f0.txt/).touch
+      rio(%w/dir1 dir10 dir000 f100.txt/).touch
+    }
+
+    tdir.chdir  {
+      io = rio('dir1')
+      exp = %w{ dir1/dir10 dir1/dir11 dir1/f0.txt}
+      assert_equal(pmap(exp), gmap(io))
+      io = rio('dir1').dirs
+      exp = %w{ dir1/dir10 dir1/dir11}
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').files
+      exp = %w{ dir1/f0.txt}
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').dirs("*1")
+      exp = %w{ dir1/dir11}
+      assert_equal(pmap(exp), gmap(io))
+      
+      io = rio('dir1').glob('**/*.txt')
+      exp = %w{dir1/f0.txt dir1/dir10/f0.txt dir1/dir10/f1.txt dir1/dir10/dir000/f100.txt}
+      assert_equal(pmap(exp), gmap(io))
+      
+      rio('dir1').chdir {
+        io = rio('dir10').files('*.txt')
+        exp = %w{ dir10/f0.txt dir10/f1.txt}
+        assert_equal(pmap(exp), gmap(io))
+
+        io = rio('dir10').files('*.txt')
+        exp = %w{ dir10/f0.txt dir10/f1.txt}
+        assert_equal(pmap(exp), gmap(io))
+      }
+    }
+    tdir.chdir  {
+      rio('dir1').chdir {
+        io = rio('dir10').files('*.txt')
+        exp = %w{ dir10/f0.txt dir10/f1.txt}
+        assert_equal(pmap(exp), gmap(io))
+        
+        io = rio('dir10').glob("**/*.txt")
+        exp = %w{ dir10/f0.txt dir10/f1.txt dir10/dir000/f100.txt}
+        assert_equal(pmap(exp), gmap(io))
+        
+        io = rio('dir10').all.files('*.txt')
+        exp = %w{ dir10/f0.txt dir10/f1.txt dir10/dir000/f100.txt}
+        assert_equal(pmap(exp), gmap(io))
+
+        io = rio('dir10').all.files
+        exp = %w{ dir10/f0.txt dir10/f1.txt dir10/f2.emp dir10/dir000/f100.txt}
+        assert_equal(pmap(exp), gmap(io))
+      }
+    }
+    tdir.chdir  {
+      io = rio('dir1').all.dirs
+      exp = %w{ dir1/dir10 dir1/dir10/dir000 dir1/dir11 dir1/dir10/dir100    }
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').all.dirs('*0')
+      exp = %w{ dir1/dir10 dir1/dir10/dir100 dir1/dir10/dir000}
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').glob('**/*100*')
+      exp = %w{ dir1/dir10/dir100 dir1/dir10/dir000/f100.txt}
+      assert_equal(pmap(exp), gmap(io))
+    }
+    tdir.chdir  {
+      io = rio('dir1').all.dirs('*0')
+      exp = %w{ dir1/dir10 dir1/dir10/dir100 dir1/dir10/dir000}
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').glob('*1')
+      exp = %w{ dir1/dir11 }
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').glob('**/*1')
+      exp = %w{ dir1/dir11 }
+      assert_equal(pmap(exp), gmap(io))
+
+      $trace_states = true
+      io = rio('dir1').recurse('*0')
+      exp = %w[dir1/dir10 dir1/dir10/dir000 dir1/dir10/dir100 dir1/dir11 dir1/f0.txt dir1/dir10/f0.txt dir1/dir10/f1.txt
+               dir1/dir10/f2.emp dir1/dir10/dir000/f100.txt]
+      $trace_states = false
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').recurse('*1')
+      exp = %w{ dir1/dir11 dir1/dir10 dir1/f0.txt}
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').recurse('*1').files
+      exp = %w{ dir1/f0.txt }
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').recurse('*1').dirs
+      exp = %w{ dir1/dir11 dir1/dir10 }
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').recurse('*1').dirs('*1')
+      exp = %w{ dir1/dir11 }
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').recurse('*0').files
+      exp = %w[dir1/f0.txt dir1/dir10/f0.txt dir1/dir10/f1.txt
+               dir1/dir10/f2.emp dir1/dir10/dir000/f100.txt]
+      assert_equal(pmap(exp), gmap(io))
+
+      io = rio('dir1').recurse('*0').files(/f\d\..../)
+      exp = %w[dir1/f0.txt dir1/dir10/f0.txt dir1/dir10/f1.txt
+               dir1/dir10/f2.emp ]
+      assert_equal(pmap(exp), gmap(io))
+
+    }
+  end
+end

data/test/tc/pid.rb

@@ -0,0 +1,31 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+
+class TC_pid < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+  end
+  def test_likeio
+    cmd = 'ruby -v'
+    ios = File.popen(cmd)
+    assert(ios.pid)
+    ios_lines = ios.readlines
+
+    ior = rio(?-,cmd)
+    assert(ior.pid)
+    ior_lines = ior.readlines
+    
+    assert_equal(ios_lines,ior_lines)
+  end
+
+end

data/test/tc/piper.rb

@@ -0,0 +1,143 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+require 'rio/piper'
+
+class TC_piper < Test::RIO::TestCase
+  @@once = false
+  @@dname = 'd'
+  @@fnames = ['f0','f1','f2','g0','g1']
+
+  require 'tc/programs_util'
+  include Test::RIO::Programs
+
+  def self.once
+    @@once = true
+    rio(@@dname).rmtree.mkpath.chdir {
+      @@fnames.each { |fn|
+        make_lines_file(2,fn)
+      }
+    }
+  end
+  def setup
+    super
+    self.class.once unless @@once
+  end
+
+  def checkit(exp,*args)
+    args.push(out = rio(?").chomp)
+    rp = RIO::Piper::Base.new(*args)
+    rp.run
+    assert_equal(exp,out[])
+    rp = RIO::Piper::Base.new(*args)
+    rp.run
+    assert_equal(exp,out[])
+    rp.run
+    assert_equal(exp,out[])
+  end
+
+  def test_cmd_out
+    ls = rio(?-,PROG['list_dir'])
+    checkit([@@dname],ls)
+  end
+
+  def test_cmd_out2
+    ls = rio(?-,PROG['list_dir']+' d')
+    checkit(@@fnames,ls)
+  end
+
+  def test_cmd_cmd_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    checkit(@@fnames.select { |s| s =~ /1/ },ls,grep)
+  end
+
+  def test_cmd_cmd_cmd_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    grep2 = rio(?-,PROG['find_lines']+' g').w!
+    checkit(@@fnames.select { |s| s =~ /g1/ },ls,grep,grep2)
+  end
+
+  def test_cmd_cmd_cmd_cmd_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    grep2 = rio(?-,PROG['find_lines']+' g').w!
+    wc = rio(?-,PROG['count_lines']).w!
+
+    checkit(["1"],ls,grep,grep2,wc)
+  end
+  def test_piper_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    rp1 = RIO::Piper::Base.new(ls,grep)
+    checkit(@@fnames.select { |s| s =~ /1/ },rp1)
+  end
+
+  def test_piper_cmd_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    rp1 = RIO::Piper::Base.new(ls,grep)
+    grep2 = rio(?-,PROG['find_lines']+' g').w!
+    checkit(@@fnames.select { |s| s =~ /g1/ },rp1,grep2)
+  end
+
+  def test_cmd_piper_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    grep2 = rio(?-,PROG['find_lines']+' g').w!
+    rp1 = RIO::Piper::Base.new(grep,grep2)
+    checkit(@@fnames.select { |s| s =~ /g1/ },ls,rp1)
+  end
+
+  def test_piper_piper_out
+    ls = rio(?-,PROG['list_dir']+' d')
+    grep = rio(?-,PROG['find_lines']+' 1').w!
+    grep2 = rio(?-,PROG['find_lines']+' g').w!
+    wc = rio(?-,PROG['count_lines']).w!
+    rp1 = RIO::Piper::Base.new(ls,grep)
+    rp2 = RIO::Piper::Base.new(grep2,wc)
+    checkit(["1"],rp1,rp2)
+  end
+
+  def test_file_out
+    f = rio('d/f2')
+    checkit(rio('d/f2').chomp[],f)
+  end
+
+  def test_file_cmd_out
+    f = rio('d/f2')
+    grep = rio(?-,PROG['find_lines']+' 2').w!
+    checkit(rio('d/f2').chomp[/2/],f,grep)
+  end
+
+  def test_file_cmd_cmd_out
+    f = rio('d/f2')
+    grep = rio(?-,PROG['find_lines']+' 2').w!
+    grep2 = rio(?-,PROG['find_lines']+' 0').w!
+    checkit(rio('d/f2').chomp[/0/],f,grep,grep2)
+  end
+
+  def test_file_cmd_cmd_cmd_out
+    f = rio('d/f2')
+    grep = rio(?-,PROG['find_lines']+' 2').w!
+    grep2 = rio(?-,PROG['find_lines']+' 0').w!
+    wc = rio(?-,PROG['count_lines']).w!
+    checkit(["1"],f,grep,grep2,wc)
+  end
+
+
+  def test_file_piper_out
+    f = rio('d/f2')
+    grep = rio(?-,PROG['find_lines']+' 2').w!
+    grep2 = rio(?-,PROG['find_lines']+' 0').w!
+    rp1 = RIO::Piper::Base.new(grep,grep2)
+    checkit(rio('d/f2').chomp[/0/],f,rp1)
+  end
+
+end

data/test/tc/programs_util.rb

@@ -0,0 +1,24 @@
+
+module Test
+  module RIO
+    module Programs
+      TEST_BIN_DIR = File.expand_path(Dir.pwd+'/bin')
+
+      XPROGS = {
+        'count_lines' => 'wc -l',
+        'find_lines'  => 'grep',
+        'list_dir'    => 'ls',
+      }
+      RPROGS = {
+        'count_lines' => "ruby #{TEST_BIN_DIR}/count_lines.rb",
+        'find_lines'  => "ruby #{TEST_BIN_DIR}/find_lines.rb",
+        'list_dir'    => "ruby #{TEST_BIN_DIR}/list_dir.rb",
+      }
+      PROG = {
+        'count_lines' => ($mswin32 ? RPROGS['count_lines'] : XPROGS['count_lines']),
+        'find_lines' => ($mswin32 ? RPROGS['find_lines'] : XPROGS['find_lines']),
+        'list_dir' => ($mswin32 ? RPROGS['list_dir'] : XPROGS['list_dir']),
+      }
+    end
+  end
+end

data/test/tc/qae.rb

@@ -0,0 +1,493 @@
+#!/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_qae < Test::Unit::TestCase
+  @@tdir = rio(%w/qp qae/)
+  @@once = false
+
+  def smap(a) a.map { |el| el.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('q1') < (0..1).map { |i| "L#{i}:d0/d1/d2/d1/q1\n" }
+                rio('q2') < (0..1).map { |i| "L#{i}:d0/d1/d2/d1/q2\n" }
+              }
+              rio('q1') < (0..1).map { |i| "L#{i}:d0/d1/d2/q1\n" }
+            }
+          }
+          rio('q1') < (0..1).map { |i| "L#{i}:d0/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d0/q2\n" }
+        }
+        
+        rio('d1').mkpath.chdir {
+          rio('d1').mkpath.chdir {
+            rio('q1') < (0..1).map { |i| "L#{i}:d1/d1/q1\n" }
+            rio('q2') < (0..1).map { |i| "L#{i}:d1/d1/q2\n" }
+          }
+          rio('d2').mkpath.chdir {
+            rio('d1').mkpath.chdir {
+              rio('q1') < (0..1).map { |i| "L#{i}:d1/d2/d1/q1\n" }
+              rio('q2') < (0..1).map { |i| "L#{i}:d1/d2/d1/q2\n" }
+            }
+            rio('d2').mkpath
+          }
+          rio('d3').mkpath.chdir {
+            rio('d1').mkpath.chdir {
+              rio('q1') < (0..1).map { |i| "L#{i}:d1/d3/d1/q1\n" }
+              rio('d1').mkpath
+            }
+            rio('q1') < (0..1).map { |i| "L#{i}:d1/d3/q1\n" }
+          }
+        }
+      end
+    end
+  end
+
+  def test_qae_fs_lines 
+    rio('qp/qae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').files.each { |f|
+            f.each { |el|
+              ans << el 
+            }
+          }
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = []
+          rio('d0').files.lines.each { |el| ans << el }
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines.files.each { |el| ans << el }
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files.lines(/L1/).each { |el| ans << el }
+          exp = ["L1:d0/q1\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines(/L1/).files.each { |el| ans << el }
+          exp = ["L1:d0/q1\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines.each { |el| ans << el }
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').lines(/L1/).each { |el| ans << el }
+          exp = ["L1:d0/q1\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+
+  def test_qae_fs_lines_ss
+    rio('qp/qae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').files.each { |f|
+            f.each { |el|
+              ans << el 
+            }
+          }
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          ans = rio('d0').files.lines[]
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines.files[]
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').files.lines[/L1/]
+          exp = ["L1:d0/q1\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines(/L1/).files[]
+          exp = ["L1:d0/q1\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines[]
+          exp = ["L0:d0/q1\n","L1:d0/q1\n","L0:d0/q2\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = rio('d0').lines[/L1/]
+          exp = ["L1:d0/q1\n","L1:d0/q2\n"]
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+
+  def test_qae_chomp 
+    rio('qp/qae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0/q1').each { |el|
+            ans << el 
+          }
+          exp = ["L0:d0/q1\n","L1:d0/q1\n"]
+          assert_equal(exp,ans)
+        end
+        
+        begin
+          ans = []
+          rio('d0/q1').chomp.each { |el|
+            ans << el 
+          }
+          exp = ["L0:d0/q1","L1:d0/q1"]
+          assert_equal(exp,ans)
+        end
+        
+      end
+    end
+  end
+
+  def test_qae_fs_nest
+    ds = ['d1/d1','d1/d2','d1/d1/q1','d1/d1/q2','d1/d2/d1','d1/d2/d1/q1','d1/d2/d1/q2','d1/d2/d2',
+          'd1/d3','d1/d3/d1','d1/d3/q1','d1/d3/d1/q1','d1/d3/d1/d1']
+    rio('qp/qae').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/q1$| }
+          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|q1$|}
+          assert_equal(smap(exp).sort,smap(ans).sort)
+        end
+
+      end
+    end
+  end
+
+  def test_qae_fs_all
+    ds = ['d0/d1','d0/d2','d0/q1','d0/q2','d0/d1/d2','d0/d1/d2/d1','d0/d1/d2/q1','d0/d1/d2/d1/q1','d0/d1/d2/d1/q2']
+    rio('qp/qae').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|q1)$/ }
+          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 =~ /q1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').all.files('*1').each { |el| ans << el }
+          exp = ds.select { |el| el =~ /q1$/ }
+          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
+  def test_qae_fs
+    rio('qp/qae').chdir do
+      begin
+        begin
+          ans = []
+          rio('d0').each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/q1','d0/q2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+      
+      
+      begin
+        begin
+          ans = []
+          rio('d0').files.each { |el| ans << el }
+          exp = ['d0/q1','d0/q2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files(/1/).each { |el| ans << el }
+          exp = ['d0/q1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files('*1').each { |el| ans << el }
+          exp = ['d0/q1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+      
+      begin
+        begin
+          ans = []
+          rio('d0').dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').dirs(/1/).each { |el| ans << el }
+          exp = ['d0/d1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').dirs('*1').each { |el| ans << el }
+          exp = ['d0/d1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+      end
+      begin
+        begin
+          ans = []
+          rio('d0').files.dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/q1','d0/q2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files(/1/).dirs.each { |el| ans << el }
+          exp = ['d0/d1','d0/d2','d0/q1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files.dirs(/1/).each { |el| ans << el }
+          exp = ['d0/d1','d0/q1','d0/q2']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+        begin
+          ans = []
+          rio('d0').files(/1/).dirs(/1/).each { |el| ans << el }
+          exp = ['d0/d1','d0/q1']
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        
+      end
+    end
+  end
+end