rio 0.3.1

data/test/tc/symlink0.rb

@@ -0,0 +1,298 @@
+#!/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_symlink0 < Test::Unit::TestCase
+  require 'extensions/symbol'
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map( &:to_s ) end
+  def tdir() rio(%w/qp symlink0/) end
+  def mkafile(*args)
+    file = rio(*args)
+    file < (0..1).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 check_link(lnk,dst)
+    assert(lnk.symlink?, "symlink?")
+    assert_equal('link',lnk.ftype)
+    assert_equal(dst.exist?,lnk.exist?)
+    if dst.exist?
+      assert_equal(dst.slurp,lnk.slurp)
+    end
+  end
+  def compare_links(exp,ans)
+    assert_equal(exp.exist?,ans.exist?)
+    assert_equal(exp.symlink?,ans.symlink?)
+    assert_equal(exp.ftype,ans.ftype)
+    assert_equal(exp.readlink.to_s,ans.readlink.to_s)
+  end
+  def test_delete
+    rio('delete').delete!.mkpath.chdir
+
+    file = mkafile('f0')
+    link = rio('l0')
+    file.symlink(link)
+
+    assert(file.exist?)
+    assert(link.exist?)
+    assert(link.symlink?)
+
+    link.delete
+    assert(file.file?,"deleted link, file still exists")
+    assert!(link.exist?,"link is deleted")
+    assert!(link.symlink?,"link is gone")
+    
+    file.symlink(link)
+    assert(file.file?,"file exists")
+    assert(link.exist?,"link exists")
+    assert(link.symlink?,"link is a symlink")
+
+    file.delete
+    assert!(file.exist?,"file deleted")
+    assert!(link.exist?,"file deleted, link.exist? returns false")
+    assert(link.symlink?,"file deleted, link is a symlink")
+
+    link.touch
+    assert(file.exist?,"link.touch creates a file")
+    assert(file.file?,"link.touch creates a file")
+
+    file.delete
+    assert!(file.exist?,"file deleted")
+    assert!(link.exist?,"file deleted, link.exist? returns false")
+    assert(link.symlink?,"file deleted, link is a symlink")
+
+    link.mkdir
+    assert(file.exist?,"link.touch creates a directory")
+    assert(file.directory?,"link.touch creates a directory")
+    
+
+    rio('..').chdir
+  end
+  def test_create
+    rio('create').delete!.mkpath.chdir
+
+    file = mkafile('f0')
+    link = rio('l0')
+    file.symlink(link)
+
+    assert(file.exist?)
+    assert(link.exist?)
+    assert(link.symlink?)
+    file.delete
+    assert!(file.exist?)
+    assert!(link.exist?)
+    assert(link.symlink?)
+
+    begin
+      afile = rio('fruby')
+      alink = rio('alink')
+      
+      ::FileUtils.touch(afile.to_s)
+      assert(afile.exist?)
+      assert(afile.file?)
+      
+      ::File.symlink(afile.to_s,alink.delete.to_s)
+      check_link(alink,afile)
+      assert(afile.file?)
+      assert(alink.exist?)
+      assert(alink.symlink?)
+      assert(alink.file?)
+      
+      ::File.delete(afile.to_s)
+      assert!(afile.exist?)
+      assert!(alink.exist?)
+      assert!(alink.file?)
+      assert(alink.symlink?)
+      
+      ::FileUtils.touch(alink)
+      assert(afile.file?,"created a file via a symlink")
+      assert(alink.exist?,"created a file via a symlink, link exists")
+      assert(alink.symlink?,"created a file via a symlink, link is a symlink")
+      assert(alink.file?,"created a file via a symlink, link is a file")
+
+      ::File.delete(afile.to_s)
+      assert!(afile.exist?)
+      assert(alink.symlink?)
+      
+      rlink = ::File.readlink(alink.to_s)
+      assert_equal(afile.to_s,rlink.to_s)
+
+      ::FileUtils.touch(rlink)
+      assert(afile.file?,"created a file via a readlink/symlink")
+      assert(alink.exist?,"created a file via a readlink/symlink, link exists")
+      assert(alink.symlink?,"created a file via a readlink/symlink, link is a symlink")
+      assert(alink.file?,"created a file via a readlink/symlink, link is a file")
+    end
+
+    begin
+      adir = rio('druby')
+      alink = rio('ldruby')
+      
+      ::Dir.mkdir(adir.to_s)
+      assert(adir.exist?)
+      assert(adir.dir?)
+      
+      ::File.symlink(adir.to_s,alink.delete.to_s)
+      
+      begin
+        assert(adir.dir?)
+        assert(alink.exist?)
+        assert(alink.symlink?)
+        assert(alink.dir?)
+        
+        assert_raise(Errno::EEXIST) { 
+          ::Dir.mkdir(alink.to_s) 
+        }
+      end
+
+      ::Dir.delete(adir.to_s)
+
+      begin
+        assert!(adir.exist?)
+        assert!(alink.exist?)
+        assert!(alink.dir?)
+        assert(alink.symlink?)
+        
+        assert_raise(Errno::EEXIST) { 
+          ::Dir.mkdir(alink.to_s) 
+        }
+      end
+
+      begin
+        assert!(adir.exist?)
+        assert!(alink.exist?)
+        assert!(alink.dir?)
+        assert(alink.symlink?)
+        
+        rlink = ::File.readlink(alink.to_s)
+        assert_equal(adir.to_s,rlink.to_s)
+        
+        ::Dir.mkdir(rlink)
+        assert(adir.dir?,"created a dir via a readlink/symlink")
+        assert(alink.exist?,"created a dir via a readlink/symlink, link exists")
+        assert(alink.symlink?,"created a dir via a readlink/symlink, link is a symlink")
+        assert(alink.dir?,"created a dir via a readlink/symlink, link is a file")
+      end
+
+    end
+
+    begin
+      adir = rio('drio')
+      alink = rio('ldrio')
+      
+      adir.mkdir
+      assert(adir.exist?)
+      assert(adir.dir?)
+      
+      adir.symlink(alink.delete)
+      
+      begin
+        assert(adir.dir?)
+        assert(alink.exist?)
+        assert(alink.symlink?)
+        assert(alink.dir?)
+        
+        assert_nothing_raised(Errno::EEXIST) { 
+          adir.mkdir
+        }
+      end
+
+      adir.delete
+
+      begin
+        assert!(adir.exist?)
+        assert!(alink.exist?)
+        assert!(alink.dir?)
+        assert(alink.symlink?)
+        #$trace_states = true
+        assert_nothing_raised(Errno::EEXIST) { 
+          alink.mkdir
+        }
+        #$trace_states = false
+        assert(adir.dir?,"created a dir via a symlink")
+        assert(alink.exist?,"created a dir via a symlink, link exists")
+        assert(alink.symlink?,"created a dir via a symlink, link is a symlink")
+        assert(alink.dir?,"created a dir via a symlink, link is a directory")
+        
+      end
+
+      adir.delete
+      
+      begin
+        assert!(adir.exist?)
+        assert!(alink.exist?)
+        assert!(alink.dir?)
+        assert(alink.symlink?)
+        
+        rlink = alink.readlink
+        assert_equal(adir.to_s,rlink.to_s)
+        
+        rlink.mkdir
+        assert(adir.dir?,"created a dir via a readlink/symlink")
+        assert(alink.exist?,"created a dir via a readlink/symlink, link exists")
+        assert(alink.symlink?,"created a dir via a readlink/symlink, link is a symlink")
+        assert(alink.dir?,"created a dir via a readlink/symlink, link is a directory")
+      end
+
+    end
+
+    begin
+      afile = rio('frio')
+      alink = rio('lrio')
+      
+      afile.touch
+      assert(afile.exist?)
+      assert(afile.file?)
+      
+      afile.symlink(alink.delete)
+      check_link(alink,afile)
+      assert(afile.file?)
+      assert(alink.exist?)
+      assert(alink.symlink?)
+      assert(alink.file?)
+      
+      afile.delete
+      assert!(afile.exist?)
+      assert!(alink.exist?)
+      assert!(alink.file?)
+      assert(alink.symlink?)
+      
+      alink.touch
+      assert(afile.file?,"created a file via a symlink")
+      assert(alink.exist?,"created a file via a symlink, link exists")
+      assert(alink.symlink?,"created a file via a symlink, link is a symlink")
+      assert(alink.file?,"created a file via a symlink, link is a file")
+
+      afile.delete
+      assert!(afile.exist?)
+      assert(alink.symlink?)
+      
+      rlink = alink.readlink
+      assert_equal(afile.to_s,rlink.to_s)
+
+      rlink.touch
+      assert(afile.file?,"created a file via a readlink/symlink")
+      assert(alink.exist?,"created a file via a readlink/symlink, link exists")
+      assert(alink.symlink?,"created a file via a readlink/symlink, link is a symlink")
+      assert(alink.file?,"created a file via a readlink/symlink, link is a file")
+    end
+
+    rio('..').chdir
+  end
+end

data/test/tc/symlink1.rb

@@ -0,0 +1,115 @@
+#!/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_symlink1 < Test::Unit::TestCase
+  require 'extensions/symbol'
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map( &:to_s ) end
+  def tdir() rio(%w/qp symlink1/) 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_lstat
+    rio('lstat').delete!.mkpath.chdir
+
+    file = mkalinesfile(100,'f0').symlink( link = rio('l0') )
+    assert(file.file?)
+    assert(link.file?)
+    assert(link.symlink?)
+
+    assert_equal(file.stat.size,link.stat.size)
+    assert_not_equal(file.stat.size,link.lstat.size)
+    assert_raise(RIO::Exception::CantHandle) {
+      file.lstat
+    }
+
+    rio('..').chdir
+  end
+  def test_stream
+    rio('stream').delete!.mkpath.chdir
+
+    file = mkalinesfile(10,'f0').symlink( link = rio('l0') )
+    assert(file.file?)
+    assert(link.file?)
+    assert(link.symlink?)
+    lines = file[]
+
+    rl = link.readlink
+    assert(link.file?)
+    assert(link.symlink?)
+    assert_equal(lines[0],link.getrec)
+    assert(link.open?)
+
+    assert_equal(rl.to_s,link.readlink.to_s)
+    assert(link.open?)
+    assert_equal(lines[1],link.getrec)
+    
+    link.lstat
+    assert(link.open?)
+    assert_equal(lines[2],link.getrec)
+    
+    link.stat
+    assert(link.open?)
+    assert_equal(lines[3],link.getrec)
+
+    link.delete
+    assert(link.closed?)
+    assert!(link.exist?)
+    assert!(link.symlink?)
+
+    rio('..').chdir
+  end
+  def test_readlink
+    rio('readlink').delete!.mkpath.chdir
+
+    file = mkafile('f0').symlink( link = rio('l0') )
+    assert(file.file?)
+    assert(link.file?)
+    assert(link.symlink?)
+
+    assert_equal(file,link.readlink)
+    assert_not_equal(file,link)
+    assert_raise(RIO::Exception::CantHandle) {
+      file.readlink
+    }
+
+    rio('..').chdir
+  end
+  def test_ftype
+    rio('ftype').delete!.mkpath.chdir
+
+    file = mkafile('f0').symlink( link = rio('l0') )
+    assert(file.file?)
+    assert(link.file?)
+    assert(link.symlink?)
+
+    assert_equal('file',file.ftype)
+    assert_equal('link',link.ftype)
+
+    rio('..').chdir
+  end
+end

data/test/tc/testcase.rb

@@ -0,0 +1,152 @@
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+require 'extensions/symbol'
+
+
+module RIOSupport
+  def supports_symlink
+    yes = true
+    begin
+      File.symlink('dummy','ldummy')
+      File.delete('ldummy')
+    rescue NotImplementedError
+      yes = false
+    rescue
+    end
+    yes
+  end
+  module_function :supports_symlink
+
+end
+$supports_symlink = RIOSupport.supports_symlink
+module RIO_TestCase 
+  module Util
+    def make_lines_file(n_lines=8,*args)
+      file = rio(*args)
+      lines = (0...n_lines).map { |i| "L#{i}:#{file}" + $/ }
+      lines.each do |line|
+        file.puts(line)
+      end
+      file.close
+      [lines,file]
+    end
+    module_function :make_lines_file
+  end
+
+  T_ROOT = 'qp'
+  def _t_dir_from_class()
+    self.class.to_s.sub(/^TC_/,'')
+  end
+  def tdir() 
+    rio(T_ROOT,_t_dir_from_class()) 
+  end
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def assert_array_equal(a,b,msg="array same regardless of order")
+    assert_equal(smap(a).sort,smap(b).sort,msg)
+  end
+  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 mklines(n_lines=8)
+    (0...n_lines).map { |i| "L#{i}\n" }
+  end
+  def mkalinesfile(n_lines,*args)
+    file = rio(*args)
+    file < (0...n_lines).map { |i| "L#{i}:#{file.to_s}\n" }
+    file
+  end
+  def lines_file(n_lines=8,*args)
+    Util::make_lines_file(n_lines,*args)
+  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 setup
+    #$trace_states = true
+    @cwd = ::Dir.getwd
+    tdir.mkpath.chdir
+  end
+  def teardown
+    ::Dir.chdir @cwd
+  end
+end
+module Test
+  module RIO
+    class TestCase < Unit::TestCase
+      def setup()
+        return if self.class == Test::RIO::TestCase
+        @cwd = ::Dir.getwd
+        tdir.mkpath.chdir
+      end
+      def teardown
+        return if self.class == Test::RIO::TestCase
+        ::Dir.chdir @cwd
+      end
+      def assert!(a,msg="negative assertion")
+        assert((!(a)),msg)
+      end
+      def assert_array_equal(a,b,msg="array same regardless of order")
+        assert_equal(smap(a).sort,smap(b).sort,msg)
+      end
+      def assert_dirs_equal(exp,d,msg="")
+        exp.each do |ent|
+          ds = rio(d,ent.filename)
+          assert(ds.exist?,"entry '#{ds}' exists")
+          assert_equal(ent.ftype,ds.ftype,"same ftype")
+          assert_rios_equal(ent,ds,"sub rios are the same")
+        end
+      end
+      def assert_rios_equal(exp,ans,msg="")
+        case
+        when exp.file?
+          assert(ans.file?,"entry is a file")
+          assert_equal(exp.readlines,ans.readlines,"file has same contents")
+        when exp.dir?
+          assert(ans.dir?,"entry is a dir")
+          assert_dirs_equal(exp,ans,"directories are the same")
+        end
+      end
+
+      def smap(a) a.map( &:to_s ) end
+      def self.make_lines_file(n_lines=8,*args)
+        file = rio(*args)
+        lines = (0...n_lines).map { |i| "L#{i}:#{file}" + $/ }
+        lines.each do |line|
+          file.puts(line)
+        end
+        file.close
+        [lines,file]
+      end
+      T_ROOT = 'qp'
+      def _t_dir_from_class()
+        self.class.to_s.sub(/^TC_/,'')
+      end
+      def self.tdir_from_class()
+        self.to_s.sub(/^TC_/,'')
+      end
+      def self.tdir()
+        rio(T_ROOT,tdir_from_class()) 
+      end
+      def tdir() 
+        rio(T_ROOT,_t_dir_from_class()) 
+      end
+      def default_test; end
+    end
+  end
+end