wishdev-rio 0.4.3.1

data/test/tc/edf.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 'test/unit'
+require 'test/unit/testsuite'
+
+class TC_RIO_edf < Test::Unit::TestCase
+  def tdir() rio(%w/qp edf/) end
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map{|el| el.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
+    unless @once
+      @once = true
+      tdir.delete!.mkpath.chdir do
+        mkafile('f1.txt')
+        mkafile('f2.asc')
+        rio('d0').mkdir
+        rio('d1').mkdir.chdir do
+          mkafile('f0.txt')
+        end
+        rio('d2').mkdir.chdir do
+          mkafile('f1.asc')
+          mkafile('f1.txt')
+          mkafile('f2.txt')
+          rio('d3').mkdir.chdir do
+            mkafile('f0.txt')
+            mkafile('f2.txt')
+            mkafile('f1.txt')
+          end
+        end
+      end
+    end
+    @cwd = ::Dir.getwd
+    tdir.mkpath.chdir
+  end
+  def teardown
+    ::Dir.chdir @cwd
+  end
+
+  def test_basic
+
+    ans = rio('d2').files[]
+    p smap(ans)
+    ans.clear
+    $trace_states = false
+    rio('d2').files(/\.txt$/).each { |ent| ans << ent }
+    $trace_states = false
+
+    p smap(ans)
+
+    ans = rio('d2').files(/\.txt$/)[]
+    p smap(ans)
+
+    ans = rio('d2').files[/\.txt$/]
+    p smap(ans)
+
+    ans = rio('d2').files('*.txt')[]
+    p smap(ans)
+
+    ans = rio('d2').files['*.txt']
+    p smap(ans)
+
+  end
+end

data/test/tc/empty.rb

@@ -0,0 +1,51 @@
+#!/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_empty < Test::RIO::TestCase
+  @@once = false
+
+  require 'tc/programs_util'
+  include Test::RIO::Programs
+
+  def self.once
+    @@once = true
+
+    rio('d0').rmtree.mkpath
+    rio('d1').rmtree.mkpath.chdir {
+      rio('file').touch
+    }
+    rio('f0').delete!.touch
+    rio('f1').puts!("a nonempty file\n")
+  end
+  def setup
+    super
+    self.class.once unless @@once
+  end
+  def test_file_empty
+    assert(rio('d0').empty?)
+  end
+  def test_file_not_empty
+    assert!(rio('d1').empty?)
+  end
+  def test_dir_empty
+    assert(rio('f0').empty?)
+  end
+  def test_dir_not_empty
+    assert!(rio('f1').empty?)
+  end
+  def test_ps_empty
+    assert(rio(?-,PROG['list_dir'] + ' d0').empty?)
+  end
+  def test_ps_not_empty
+    assert!(rio(?-,PROG['list_dir'] + ' d1').empty?)
+  end
+  def test_dev_null_empty
+    assert(rio(nil).empty?)
+  end
+end

data/test/tc/emptyriodir.rb

@@ -0,0 +1,129 @@
+#!/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_emptyriodir < Test::RIO::TestCase
+  include RIO_TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('adir').mkdir.chdir {
+      rio('a.rb').touch  
+      rio('b.rb').touch
+      rio('c.txt').touch
+    }
+    rio('d.rb').touch
+    rio('e.txt').touch
+    rio('f.d').mkdir
+  end
+
+  def setup
+    super
+    self.class.once unless @@once
+  end
+
+  def test_ss
+    
+    dotans = rio('.')[]
+    empans = rio[]
+    assert_array_equal(dotans,empans)
+
+    dotans = rio('.')['*.rb']
+    empans = rio['*.rb']
+    assert_array_equal(dotans,empans)
+
+  end
+
+  def test_each
+
+    dotans = []
+    empans = []
+    rio('.').each{ |el| dotans << el }
+    rio.each{ |el| empans << el }
+    assert_array_equal(dotans,empans)
+
+    dotans = []
+    empans = []
+    rio('.').entries('*.rb') { |el| dotans << el }
+    rio.entries('*.rb') { |el| empans << el }
+    assert_array_equal(dotans,empans)
+  end
+
+  def test_read
+    dotans = []
+    empans = []
+    dotrio = rio('.')
+    emprio = rio
+    while s = dotrio.read do dotans << s end
+    while s = emprio.read do empans << s end
+    assert_array_equal(dotans,empans)
+  end
+
+  def test_get
+    dotans = []
+    empans = []
+    dotrio = rio('.')
+    emprio = rio
+    while s = dotrio.get do dotans << s end
+    while s = emprio.get do empans << s end
+    assert_array_equal(dotans,empans)
+
+    dotans = []
+    empans = []
+    dotrio = rio('.').entries('*.d')
+    emprio = rio.entries('*.d')
+    while s = dotrio.get do dotans << s end
+    while s = emprio.get do empans << s end
+    assert_array_equal(dotans,empans)
+
+  end
+
+  def test_skip
+    
+    dotans = rio('.').skip[]
+    empans = rio.skip[]
+    assert_array_equal(dotans,empans)
+
+    dotans = rio('.').skip['*.rb']
+    empans = rio.skip['*.rb']
+    assert_array_equal(dotans,empans)
+
+  end
+
+  def test_dirs
+    
+    dotans = rio('.').dirs[]
+    empans = rio.dirs[]
+    assert_array_equal(dotans,empans)
+
+    dotans = rio('.').dirs['*.d']
+    empans = rio.dirs['*.d']
+    assert_array_equal(dotans,empans)
+
+  end
+
+
+  def test_getwd
+    dotans = rio('.').getwd
+    empans = rio.getwd
+    assert_array_equal(dotans,empans)
+  end
+
+  def test_rmdir
+    rio('empty.d').delete!.mkdir.chdir {
+      assert_raise(RIO::Exception::CantHandle) { rio.rmdir }
+    }
+  end
+
+  def test_rmtree
+    rio('empty.d').delete!.mkdir.chdir {
+      assert_raise(RIO::Exception::CantHandle) { rio.rmtree }
+    }
+  end
+
+end

data/test/tc/entary.rb

@@ -0,0 +1,227 @@
+#!/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_RIO_entary < Test::Unit::TestCase
+  def smap(a) a.map { |el| el.to_s } end
+  def tdir() rio(%w/qp entary/) 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/entary').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_entary_nofile
+    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]
+    return unless $supports_symlink
+    rio('qp/entary').chdir do
+      begin
+        rio('d1').delete!.mkpath.chdir do
+          rio('q1') < (0..1).map { |i| "L#{i}:d1/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d1/q2\n" }
+          rio('q1').symlink('lq1')
+          rio('d1').mkdir
+          rio('d1').symlink('ld1')
+          rio('d2').mkdir
+        end
+        ds = %w[d1/q1 d1/q2 d1/d1 d1/d2 d1/lq1 d1/ld1]
+        begin
+          ans = rio('d1').files[]
+          exp = ds.select { |el| el =~ /q\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[]
+          exp = ds.select { |el| el =~ /d\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[]
+          exp = ds.select { |el| el =~ /(l)?[qd]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          rio('d1/q1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/q1$| }
+
+          ans = rio('d1').files[]
+          exp = ds.select { |el| el =~ /q2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[]
+          exp = ds.select { |el| el =~ /d\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[]
+          exp = ds.select { |el| el =~ /(l)?[qd]\d$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          rio('d1/d1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/d11$| }
+          
+          ans = rio('d1').files[]
+          exp = ds.select { |el| el =~ /q2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[]
+          exp = ds.select { |el| el =~ /d2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[]
+          exp = ds.select { |el| el =~ /l[qd]1$/ or el =~ /[qd]2$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+      end
+    end
+  end
+  def test_entary_nofile_symlink
+    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]
+    return unless $supports_symlink
+    rio('qp/entary').chdir do
+      begin
+        rio('d1').delete!.mkpath.chdir do
+          rio('q1') < (0..1).map { |i| "L#{i}:d1/q1\n" }
+          rio('q2') < (0..1).map { |i| "L#{i}:d1/q2\n" }
+          rio('q1').symlink('lq1')
+          rio('d1').mkdir
+          rio('d1').symlink('ld1')
+          rio('d2').mkdir
+        end
+        ds = %w[d1/q1 d1/q2 d1/d1 d1/d2 d1/lq1 d1/ld1]
+
+        begin
+          ans = rio('d1').files[/1/]
+          exp = ds.select { |el| el =~ /q1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[/1/]
+          exp = ds.select { |el| el =~ /d1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[/1/]
+          exp = ds.select { |el| el =~ /(l)?[qd]1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+        begin
+          rio('d1/q1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/q1$| }
+
+          ans = rio('d1').files[/1/]
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[/1/]
+          exp = ds.select { |el| el =~ /d1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+
+          ans = rio('d1').entries[/1/]
+          exp = ds.select { |el| el =~ /(l)?[qd]1$/ }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+        begin
+          rio('d1/d1').delete
+          ds = ds.reject { |el| el =~ %r|^d1/d11$| }
+          
+          ans = rio('d1').files[/1/]
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').dirs[/1/]
+          exp = []
+          assert_equal(exp.sort,smap(ans).sort)
+          
+          ans = rio('d1').entries[/1/]
+          exp = ds.select { |el| el =~ /l[qd]1$/  }
+          assert_equal(exp.sort,smap(ans).sort)
+        end
+
+      end
+    end
+  end
+  def test_entary
+    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/entary').chdir do
+      begin
+        ans = []
+        exp = []
+        rio('d0').dirs.files.each { |ent| exp << ent }
+
+        ans.clear
+        rio('d0').entries.each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans.clear
+        rio('d0').entries { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans = rio('d0').entries[]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+      end
+
+      begin
+        ans = []
+        exp = []
+        rio('d0').dirs(/1/).files(/1/).each { |ent| exp << ent }
+
+        ans.clear
+        rio('d0').entries(/1/).each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans.clear
+        rio('d0').entries(/1/) { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans = rio('d0').entries[/1/]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+        ans = rio('d0')[/1/]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+
+      end
+
+      begin
+        ans = []
+        exp = []
+        rio('d0').entries(/1/).each { |ent| exp << ent }
+        rio('d0').files.each { |ent| exp << ent unless exp.include?(ent)}
+        
+        ans.clear
+        rio('d0').entries(/1/).files.each { |ent| ans << ent }
+        assert_equal(smap(exp).sort,smap(ans).sort)
+        
+        ans = rio('d0').files.entries[/1/]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+        
+        ans = rio('d0').entries(/1/).files[]
+        assert_equal(smap(exp).sort,smap(ans).sort)
+        
+      end
+      
+    end
+  end
+end