wishdev-rio 0.4.3.1

data/test/tc/dirautoclose.rb

@@ -0,0 +1,67 @@
+#!/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_dirss < Test::Unit::TestCase
+  include RIO_TestCase
+  def setup()
+    super
+    unless @once
+      @once = true
+      @l = []; @f = []; @d = []
+      @d[0] = rio('a').rmtree.mkpath
+      @d[1] = rio('b').rmtree.mkpath
+      #$trace_states = false
+      #$trace_states = true
+      @l[0],@f[0] = lines_file(3,'a/f0')
+      @l[1],@f[1] = lines_file(2,'a/f1')
+      @d[1] < @d[0]
+      @d[1] < @d[0].files[]
+    end
+  end
+  def test_rename_add_ext_check_
+#  p 'test_copyto_dir'
+    assert_equal(@l[0],rio(@d[1],@f[0].basename).lines[])
+    assert_equal(@l[1],rio(@d[1],@f[1].basename).lines[])
+    rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    indir = rio('tdir')
+    #indir = @d[1]
+    $trace_states = true
+    p indir.map{|el| el.to_s}
+    ary = indir[]
+    #p ary.map{|el| el.to_s}
+    p indir,indir.ioh
+    newext = '.txt'
+    indir.files.rename.each { |ent|
+      ent.extname = newext
+    }
+    $trace_states = false
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename.to_s + newext).lines[])
+  end
+  def atest_rename_add_ext_check_
+#  p 'test_copyto_dir'
+    assert_equal(@l[0],rio(@d[1],@f[0].basename).lines[])
+    assert_equal(@l[1],rio(@d[1],@f[1].basename).lines[])
+    rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    indir = rio('tdir')
+    #indir = @d[1]
+    $trace_states = true
+    p indir.map{|el| el.to_s}
+    ary = indir[]
+    #p ary.map{|el| el.to_s}
+    p indir,indir.ioh
+    newext = '.txt'
+    indir.files.rename.each { |ent|
+      ent.extname = newext
+    }
+    $trace_states = false
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename.to_s + newext).lines[])
+  end
+end

data/test/tc/dirent.rb

@@ -0,0 +1,178 @@
+#!/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_dirent < Test::Unit::TestCase
+  def smap(a) a.map { |el| el.to_s } end
+  def tdir() rio(%w/qp dirent/) end
+  def mkafile(*args)
+    file = rio(*args)
+    file < (0..1).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def setup() 
+    $trace_states = false
+    rio('qp/dirent').delete!.mkpath.chdir do
+      rio('d0').mkpath.chdir do
+        rio('q1') < (0..1).map { |i| "L#{i}:d0/q1\n" }
+        rio('q2') < (0..1).map { |i| "L#{i}:d0/q2\n" }
+        rio('d1').mkdir.chdir do
+          rio('q1') < (0..1).map { |i| "L#{i}:d0/d1/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d0/d1/q2\n" }
+          rio('d1').mkdir.chdir do
+            rio('q1') < (0..1).map { |i| "L#{i}:d0/d1/d1/q1\n" }
+            rio('q2') < (0..1).map { |i| "L#{i}:d0/d1/d1/q2\n" }
+          end
+          rio('d2').mkdir
+        end
+        rio('d2').mkdir
+      end
+    end
+  end
+  def test_dirent
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d1/q1 d0/d1/d1/q2]
+    rio('qp/dirent').chdir do
+      begin
+        ans = []
+        rio('d0').entries.each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|^d0/.\d$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').entries(/1/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|^d0/.1$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').entries(/2/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|^d0/.2$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+    end
+  end
+  def test_dirent_mixed
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d1/q1 d0/d1/d1/q2]
+    rio('qp/dirent').chdir do
+      begin
+        exp = []
+        ans = []
+        rio('d0').entries.each { |ent| ans << ent }
+        rio('d0').files.dirs.each { |ent| exp << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+      end
+
+      begin
+        re = /1/
+        exp = []
+        rio('d0').entries(re).each { |ent| exp << ent }
+        rio('d0').files.each { |ent| exp << ent unless exp.include?(ent) }
+
+        ans = []
+        rio('d0').entries(re).files.each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+      end
+
+      begin
+        re = /1/
+        exp = []
+        rio('d0').entries(re).each { |ent| exp << ent }
+        rio('d0').dirs.each { |ent| exp << ent unless exp.include?(ent) }
+
+
+        ans = []
+        rio('d0').entries(re).dirs.each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+      end
+
+    end
+  end
+  def test_dirent_files
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d1/q1 d0/d1/d1/q2]
+    rio('qp/dirent').chdir do
+
+      begin
+        ans = []
+        rio('d0').entries(/1/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|^d0/.1$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').entries(/2/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|^d0/.2$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+    end
+  end
+  def test_dirent_all
+    ds = %w[d0/q1 d0/q2 d0/d1 d0/d2 d0/d1/q1 d0/d1/q2 d0/d1/d1 d0/d1/d2 d0/d1/d1/q1 d0/d1/d1/q2]
+    rio('qp/dirent').chdir do
+      begin
+        ans = []
+        rio('d0').all.entries.each do |ent|
+          ans << ent
+        end
+        exp = ds.dup
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').all.entries(/1/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|1$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').all.entries(/2/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|2$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').all.entries(/q/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|q\d$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+      begin
+        ans = []
+        rio('d0').all.entries(/d/).each do |ent|
+          ans << ent
+        end
+        exp = ds.select { |el| el =~ %r|d\d$| }
+        assert_equal(exp.sort,smap(ans).sort)
+      end
+
+    end
+  end
+end

data/test/tc/dirss.rb

@@ -0,0 +1,81 @@
+#!/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_dirss < Test::Unit::TestCase
+  include RIO_TestCase
+  def setup()
+    super
+    unless @once
+      @once = true
+    end
+  end
+  def ztest_simple
+#  p 'test_copyto_dir'
+    d = rio('tdir').delete!.mkpath
+    p d[]
+    p d[]
+  end
+  def ztest_o
+#  p 'test_copyto_dir'
+    d = rio('tdir').delete!.mkpath
+    f = rio(d,'f').touch
+    sd = rio(d,'sd').mkpath
+    p d[]
+    d.files.each do |ent|
+      #ent.extname = '.txt'
+      p "#{ent} #{ent.ftype}"
+    end
+  end
+  def ztest_each
+#  p 'test_copyto_dir'
+    d = rio('tdir').delete!.mkpath
+    f = rio(d,'f').touch
+    sd = rio(d,'sd').mkpath
+    d.entries.each do |ent|
+      p "#{ent} #{ent.ftype}"
+    end
+    d.files.each do |ent|
+      #ent.extname = '.txt'
+      p "#{ent} #{ent.ftype}"
+    end
+  end
+  def test_dirs_files
+#  p 'test_copyto_dir'
+    d = rio('tdir').delete!.mkpath
+    f = rio(d,'f').touch
+    sd = rio(d,'sd').mkpath
+    d.dirs.each do |ent|
+      p "#{ent} #{ent.ftype}"
+    end
+    d.files.each do |ent|
+      #ent.extname = '.txt'
+      p "#{ent} #{ent.ftype}"
+    end
+  end
+  def atest_rename_add_ext_check_
+#  p 'test_copyto_dir'
+    assert_equal(@l[0],rio(@d[1],@f[0].basename).lines[])
+    assert_equal(@l[1],rio(@d[1],@f[1].basename).lines[])
+    rio('tdir').delete!.mkpath < rio(@d[1]).to_a
+    indir = rio('tdir')
+    #indir = @d[1]
+    $trace_states = true
+    p indir.map{|el| el.to_s}
+    ary = indir[]
+    #p ary.map{|el| el.to_s}
+    p indir,indir.ioh
+    newext = '.txt'
+    indir.files.rename.each { |ent|
+      ent.extname = newext
+    }
+    $trace_states = false
+    assert_equal(@l[0],rio(indir,@f[0].basename.to_s + newext).lines[])
+    assert_equal(@l[1],rio(indir,@f[1].basename.to_s + newext).lines[])
+  end
+end

data/test/tc/each.rb

@@ -0,0 +1,111 @@
+#!/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_each < Test::Unit::TestCase
+  def test_basic
+    qp = rio('qp')
+    rio(qp,'test_each').rmtree.mkpath.chdir do
+      f = rio('basic.txt')
+      0.upto(6) do |n|
+        f.puts("L#{n+1}: #{n*3}:#{n*2}")
+      end
+      f.puts!("Line Z")
+      
+      expa = ["L1: 0:0\n", "L2: 3:2\n", "L3: 6:4\n", "L4: 9:6\n", "L5: 12:8\n", "L6: 15:10\n", "L7: 18:12\n", 
+              "Line Z\n"]
+      
+      ans = []
+      
+      rio('basic.txt').lines { |line| ans.push(line) }
+      assert_equal(expa,ans)
+      ans.clear
+      
+      rio('basic.txt').lines.each { |line| ans.push(line) }
+      assert_equal(expa,ans)
+      ans.clear
+
+      rio('basic.txt').each { |line| ans.push(line) }
+      assert_equal(expa,ans)
+      ans.clear
+      
+      # proxy of IO#each_line -- lines() is ignored
+      rio('basic.txt').each_line { |line| ans.push(line) }
+      assert_equal(expa,ans)
+      ans.clear
+      
+      assert_equal(expa,rio('basic.txt').lines.to_a)
+      assert_equal(expa,rio('basic.txt').to_a)
+      
+      ans = rio('basic.txt').lines(1..3).to_a
+      assert_equal(expa[1..3],ans)
+      ans = rio('basic.txt').lines(1..1,5..6).to_a
+      assert_equal(expa[1..1] + expa[5..6],ans)
+      ans = rio('basic.txt').lines(1,5..6).to_a
+      assert_equal(expa[1..1] + expa[5..6],ans)
+      
+      assert_equal([expa[1],expa[4],expa[6]],rio('basic.txt').lines(/2/).to_a)
+      
+      ans = []
+      rio('basic.txt').chomp.lines(/2/).each { |line| ans.push(line) }
+      assert_equal([expa[1],expa[4],expa[6]].map{|el| el.chomp},ans)
+      
+      ans = []
+      rio('basic.txt').chomp.lines(/2/) { |line| ans.push(line) }
+      assert_equal([expa[1],expa[4],expa[6]].map{|el| el.chomp},ans)
+      
+      ans = []
+      rio('basic.txt').lines(/2/).chomp { |line| ans.push(line) }
+      assert_equal([expa[1],expa[4],expa[6]].map{|el| el.chomp},ans)
+      
+      
+      expb = ["L1: 0:0\nL2: 3:2\nL3: 6:4\nL4: 9:6\n", "L5: 12:8\nL6: 15:10\nL7: 18:12\nLin", "e Z\n"]
+      
+      assert_equal(expb,rio('basic.txt').bytes(32).to_a)
+      assert_equal(expb[0..1],rio('basic.txt').records(0..1).bytes(32).to_a)
+      assert_equal(expb[0..1],rio('basic.txt').bytes(32).records(0..1).to_a)
+      
+      ans = []
+      rio('basic.txt').bytes(32) { |rec| ans << rec }
+      assert_equal(expb,ans)
+      
+      ans = []
+      rio('basic.txt').bytes(32).each { |rec| ans << rec }
+      assert_equal(expb,ans)
+      
+      ans = []
+      rio('basic.txt').records(1..2).bytes(32).each { |rec| ans << rec }
+      assert_equal(expb[1..2],ans)
+      
+      ans = []
+      rio('basic.txt').records(1..2).bytes(32) { |rec| ans << rec }
+      assert_equal(expb[1..2],ans)
+      
+      ans = []
+      rio('basic.txt').bytes(32).records(1..2).each { |rec| ans << rec }
+      assert_equal(expb[1..2],ans)
+      
+      ans = []
+      rio('basic.txt').bytes(32).records(1..2) { |rec| ans << rec }
+      assert_equal(expb[1..2],ans)
+      
+      assert_equal(expb[0..2],rio('basic.txt').bytes(32).records(0..2).to_a)
+      
+#      expc = [["15", "10"], ["18", "12"]]
+#      assert_equal(expc,rio('basic.txt').lines(/(\d\d):(\d\d)/).to_a)
+      
+#      ans = []
+#      rio('basic.txt').lines(/(\d\d):(\d\d)/) { |ary|
+#        ans.push(ary)
+#      }
+#      assert_equal(expc,ans)
+
+    end
+  end
+end
+

data/test/tc/each_break.rb

@@ -0,0 +1,243 @@
+#!/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_each_break < Test::Unit::TestCase
+  @@once = false
+  include RIO_TestCase
+  def self.once
+    return if @@once
+    @@once = true
+    rio('dir').rmtree.mkdir.chdir do
+      %w[d1 d2].each { |dname| rio(dname).delete!.mkdir }
+      Util::make_lines_file(1,'f1')
+      Util::make_lines_file(2,'f2')
+      Util::make_lines_file(3,'f3')
+      Util::make_lines_file(1,'d1','f1')
+      Util::make_lines_file(1,'d2','f1')
+      Util::make_lines_file(2,'d2','f2')
+    end
+  end
+  def setup()
+    super
+    self.class.once unless @@once
+    @dir = rio('dir')
+    @f1 = rio(@dir,'f1')
+    @f2 = rio(@dir,'f2')
+    @f3 = rio(@dir,'f3')
+    @l1 = @f1.readlines
+    @l2 = @f2.readlines
+    @l3 = @f3.readlines
+    @d1 = rio(@dir,'d1')
+    @d2 = rio(@dir,'d2')
+    @e1 = %w[d1/f1].map { |ent| rio(@dir,ent) }
+    @e2 = %w[d2/f1 d2/f2].map { |ent| rio(@dir,ent) }
+    @files = [@f1,@f2,@f3]
+    @dirs = [@d1,@d2]
+    @ents = @dirs + @files
+  end
+  def test_nobreak_dir
+    ans = []
+    @d1.each { |ent| ans << ent }
+    assert(@d1.closed?)
+    assert_equal(@e1,ans)
+
+    ans = []
+    @d2.each { |ent| ans << ent }
+    assert(@d2.closed?)
+    assert_equal(@e2,ans)
+
+  end
+
+  def test_nobreak_dir_sel
+    ans = []
+    @dir.entries.each { |ent| ans << ent }
+    assert_array_equal(@ents ,ans)
+
+    ans = []
+    @dir.files.each { |ent| ans << ent }
+    assert_array_equal(@files,ans)
+
+    ans = []
+    @dir.dirs.each { |ent| ans << ent }
+    assert_array_equal(@dirs,ans)
+
+  end
+  def test_dir_sel
+    ans = []
+    @dir.entries.each { |ent| ans << ent; break }
+    assert_array_equal(@ents[0..0],ans)
+
+    ans = []
+    @dir.files.each { |ent| ans << ent; break }
+    assert_array_equal(@ents[1..1],ans)
+
+    ans = []
+    @dir.dirs.each { |ent| ans << ent; break }
+    assert_array_equal(@ents[2..2],ans)
+    
+    @dir.close
+    assert(@dir.closed?)
+
+    ans = []
+    @dir.dirs.each { |ent| ans << ent; break }
+    assert_array_equal(@dirs[0..0],ans)
+    
+    ans = []
+    @dir.files.each { |ent| ans << ent; break }
+    assert_array_equal(@ents[1..1],ans)
+
+    ans = []
+    @dir.entries.each { |ent| ans << ent; break }
+    assert_array_equal(@ents[2..2],ans)
+
+    @dir.close
+    assert(@dir.closed?)
+
+    ans = []
+    @dir.files.each { |ent| ans << ent; break }
+    assert_array_equal(@files[0..0],ans)
+
+    ans = []
+    @dir.dirs.each { |ent| ans << ent; break }
+    assert_array_equal(@files[1..1],ans)
+
+    ans = []
+    @dir.entries.each { |ent| ans << ent; break }
+    assert_array_equal(@files[2..2],ans)
+
+    ans = []
+    @dir.entries.each { |ent| ans << ent; break }
+    assert_array_equal([],ans)
+
+  end
+  def test_dir_oneentry
+    ans = []
+    @d1.each { |ent| ans << ent; break }
+    assert(@d1.open?)
+    assert_equal(@e1[0..0],ans)
+
+    ans = []
+    @d2.each { |ent| ans << ent; break }
+    assert(@d2.open?)
+    assert_equal(@e2[0..0],ans)
+
+  end
+  def test_dir_readmore
+    ans = []
+    ### LOOK INTO THIS
+    ### Something changed in ruby 1.8.3
+    ### See the file q/dir_readmore.q for a simple example
+    dir1 = rio(@d1)
+    dir1.each { |ent| 
+      ans << ent; 
+      break 
+    }
+    assert(dir1.open?)
+    assert_equal(@e1[0..0],ans)
+
+    ans = []
+    #$trace_states = true
+    dir1.each { |ent| ans << ent; break }
+    assert(dir1.closed?)
+    assert_equal([],ans)
+
+    dir2 = rio(@d2)
+
+    ans = []
+    dir2.each { |ent| ans << ent; break }
+    assert(dir2.open?)
+    assert_equal(@e2[0..0],ans)
+
+    ans = []
+    dir2.each { |ent| ans << ent; break }
+    assert(dir2.open?)
+    assert_equal(@e2[1..1],ans)
+
+    ans = []
+    dir2.each { |ent| ans << ent; break }
+    assert(dir2.closed?)
+    assert_equal([],ans)
+
+  end
+  def test_nobreak_lines
+    ans = []
+    @f1.each { |line| ans << line }
+    assert(@f1.closed?)
+    assert_equal(@l1,ans)
+
+    ans = []
+    @f2.each { |line| ans << line }
+    assert(@f2.closed?)
+    assert_equal(@l2,ans)
+
+    ans = []
+    @f3.each { |line| ans << line }
+    assert(@f3.closed?)
+    assert_equal(@l3,ans)
+
+  end
+  def test_lines_oneline
+    ans = []
+    @f1.each { |line| ans << line; break }
+    assert_equal(@l1[0..0],ans)
+    assert(@f1.eof?)
+    assert(@f1.open?)
+
+    ans = []
+    @f2.each { |line| ans << line; break }
+    assert_equal(@l2[0..0],ans)
+    assert!(@f2.eof?)
+    assert(@f2.open?)
+
+    ans = []
+    @f3.each { |line| ans << line; break }
+    assert_equal(@l3[0..0],ans)
+    assert!(@f3.eof?)
+    assert(@f3.open?)
+
+  end
+  def test_lines_threelines
+    ans = []
+    @f1.each { |line| ans << line; break }
+    assert_equal(@l1[0..0],ans)
+    assert(@f1.eof?)
+    assert(@f1.open?)
+
+    ans = []
+    @f1.each { |line| ans << line; break }
+    assert(@f1.eof?,"read 2 at eof")
+    assert(@f1.closed?,"read 2 causes close")
+    assert_equal([],ans)
+
+    ans = []
+    @f1.each { |line| ans << line; break }
+    assert(@f1.eof?,"read 3 at eof")
+    assert(@f1.open?,"read 3 leaves file open")
+    assert_equal(@l1[0..0],ans)
+
+    ans = []
+    @f2.each { |line| ans << line; break }
+    assert_equal(@l2[0..0],ans)
+    assert!(@f2.eof?)
+    assert(@f2.open?)
+
+    ans = []
+    @f2.each { |line| ans << line; break }
+    assert(@f2.eof?,"read 2 at eof")
+    assert(@f2.open?,"read 2 does not close close")
+    assert_equal(@l2[1..1],ans)
+
+    ans = []
+    @f2.each { |line| ans << line; break }
+    assert(@f2.eof?,"read 3 at eof")
+    assert(@f2.closed?,"read 3 closes")
+    assert_equal([],ans)
+
+  end
+end