wishdev-rio 0.4.3.1

data/test/tc/lineno.rb

@@ -0,0 +1,196 @@
+#!/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_lineno < Test::Unit::TestCase
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+  def smap(a) a.map{|el| el.to_s} end
+  def tdir() rio(%w/qp lineno/) 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 ztest_lineno_0
+    rio('lineno').delete!.mkpath.chdir
+
+    file = mkalinesfile(10,'f0')
+    lines = file[]
+
+    pos = file.pos
+    lnum = file.lineno
+    line = file.readline
+    p "pos=#{pos}, lnum=#{lnum}, line=#{line}"
+
+    pos = file.pos
+    lnum = file.lineno
+    line = file.readline
+    p "pos=#{pos}, lnum=#{lnum}, line=#{line}"
+
+
+    file.close
+    rio('..').chdir
+  end
+  # baoo code 4153
+
+  def test_lineno_like_IO
+    rio('lineno').delete!.mkpath.chdir
+
+    frio = mkalinesfile(5,'frio')
+    rio('fruby') < frio
+
+    fruby = File.open('fruby');
+
+    assert_equal(fruby.pos,frio.pos)
+    assert_equal(fruby.lineno,frio.lineno)
+    assert_equal(line = fruby.readline,frio.readline)
+
+    assert_equal(fruby.pos,frio.pos)
+    assert_equal(fruby.lineno,frio.lineno)
+    assert_equal(line = fruby.readline,frio.readline)
+
+    fruby.pos += line.length
+    frio.pos += line.length
+    
+    assert_equal(fruby.pos,frio.pos)
+    assert_equal(fruby.lineno,frio.lineno)
+    assert_equal(line = fruby.readline,frio.readline)
+
+
+    $trace_states = false
+    fruby.close
+    frio.close
+
+    fruby = File.open('fruby');
+    frio = rio('frio')
+
+    p fruby.lineno
+    fruby.each { |rec|
+      p "#{fruby.lineno} >> #{rec}"
+    }
+
+    p frio.lineno
+    frio.each { |rec|
+      p "#{frio.lineno} >> #{rec}"
+    }
+    frio.close
+    p "RECNO"
+    $trace_states = true
+
+    frio = rio('frio')
+    p frio.recno
+    frio.each { |rec|
+      p "#{frio.recno} >> #{rec}"
+    }
+    $trace_states = false
+    frio.close
+
+#    fruby.close
+#    p fruby.lineno
+
+    rio('..').chdir
+
+    
+
+
+ end
+
+
+
+
+
+  def test_lineno
+    rio('lineno').delete!.mkpath.chdir
+
+    file = mkalinesfile(10,'f1')
+    lines = file[]
+
+#    $trace_states = true
+    file = rio('f1')
+    
+    assert_equal(0,file.lineno)
+    assert_equal(lines[0],file.readline)
+    assert_equal(1,file.lineno)
+
+    assert_equal(lines[1],file.readline)
+#    p file.recno
+
+
+    $trace_states = false
+    file.close
+    rio('..').chdir
+  end
+
+  def test_recno
+    rio('recno').delete!.mkpath.chdir
+
+    file = mkalinesfile(3,'f0')
+    lines = file[]
+
+    $trace_states = false
+    file = rio('f0')
+    p file.recno
+    file.each { |rec|
+      p "#{file.recno} >> #{rec}"
+    }
+
+
+
+
+
+    file.close
+
+
+
+
+    $trace_states = false
+    file.close
+    rio('..').chdir
+  end
+
+  def test_eof
+    rio('lineno').delete!.mkpath.chdir
+
+    file = mkalinesfile(3,'f0')
+    file > (lines = [])
+    $trace_states = false
+    file = rio('f0')
+    p file.eof?
+
+
+    $trace_states = false
+#    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
+end

data/test/tc/lines.rb

@@ -0,0 +1,66 @@
+#!/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_lines < Test::Unit::TestCase
+  def test_basic
+    qp = rio('qp')
+
+    rio(qp,'test_lines').rmtree.mkpath.chdir {
+      
+      f = rio('basic.txt')
+      0.upto(6) do |n|
+        f.puts("L#{n}: #{n*3}:#{n*2}")
+      end
+      f.puts!("Line Z")
+      
+      expa = ["L0: 0:0\n", "L1: 3:2\n", "L2: 6:4\n", "L3: 9:6\n", "L4: 12:8\n", "L5: 15:10\n", "L6: 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)
+      
+      
+      expa = ["L1: 3:2\n", "L2: 6:4\n", "L4: 12:8\n", "L6: 18:12\n"]
+      assert_equal(expa,rio('basic.txt').lines(/2/).to_a)
+      
+      expa = ["L0: 0:0\nL1: 3:2\nL2: 6:4\nL3: 9:6\n", "L4: 12:8\nL5: 15:10\nL6: 18:12\nLin", "e Z\n"]
+      assert_equal(expa,rio('basic.txt').bytes(32).to_a)
+      
+#      expa = [["15", "10"], ["18", "12"]]
+#      assert_equal(expa,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(expa,ans)
+    }
+  end
+  
+end
+  

data/test/tc/misc.rb

@@ -0,0 +1,432 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'tc/testcase'
+#require 'dev-utils/debug'
+
+#require 'tc_myfirsttests'
+#require 'tc_moretestsbyme'
+#require 'ts_anothersetoftests'
+
+class TC_RIO_misc < Test::Unit::TestCase
+  def rio(*args) RIO.rio(*args) end
+  def rootrio(*args) RIO.root(*args) end
+  def ttdir() RIO.rio('qp').mkpath end
+  def assert_equal_s(a,b) assert_equal(a.to_s,b.to_s) end
+
+  def test_iomodes
+    exp = (0..5).to_a.map { |n| "Line #{n}" }
+    f = rio('qp/rwlines.txt').chomp
+    0.upto(4) do |n|
+      f.puts("Line #{n}")
+    end
+    got =  f.a.puts("Line 5").readlines
+    assert_equal(exp,got)
+
+    f = rio('qp/rwlines.txt').mode('w')
+    0.upto(4) { |n| f.puts("Line #{n}") }
+    assert_raise(IOError) {
+      f.readlines
+    }
+
+    f = rio('qp/rwlines.txt').a
+    assert_equal_s('a',f.outputmode?)
+    f.puts("Line 0\n\n")
+#    assert_match(/Output$/,.handled_by)
+    assert_equal_s('a',f.mode?)
+    assert_equal("Line 0\n",f.rewind.gets);
+    assert_equal_s('r',f.mode?)
+#    assert_match(/Input$/,f.handled_by)
+
+    f = rio('qp/rwlines.txt').a!
+    assert_equal_s('a+',f.outputmode?)
+    f.puts("Line 0\n\n")
+#    assert_match(/InOut$/,f.puts("Line 0\n\n").handled_by)
+    assert_equal_s('a+',f.mode?)
+    assert_equal("Line 0\n",f.rewind.gets);
+    assert_equal_s('a+',f.mode?)
+#    assert_match(/InOut$/,f.handled_by)
+
+    f = rio('qp/rwlines.txt').w
+    assert_equal_s('w',f.outputmode?)
+    f.puts("Line 0\n\n")
+#    assert_match(/Output$/,f.puts("Line 0\n\n").handled_by)
+    assert_equal_s('w',f.mode?)
+    assert_equal("Line 0\n",f.rewind.gets);
+    assert_equal_s('r',f.mode?)
+#    assert_match(/Input$/,f.handled_by)
+
+    f = rio('qp/rwlines.txt').w!
+    assert_equal_s('w+',f.outputmode?)
+    f.puts("Line 0").puts("Line 1")
+#    assert_match(/InOut$/,f.puts("Line 0").puts("Line 1").handled_by)
+    assert_equal_s('w+',f.mode?)
+    assert_equal("Line 0\n",f.rewind.gets);
+    assert_equal_s('w+',f.mode?)
+#    assert_match(/InOut$/,f.handled_by)
+
+    f = rio('qp/rwlines.txt').r
+    assert_equal_s('r',f.inputmode?)
+    f.puts("Line 0").puts("Line 1")
+#    assert_match(/Output$/,f.puts("Line 0").puts("Line 1").handled_by)
+    assert_equal_s('w',f.mode?)
+    assert_equal("Line 0\n",f.rewind.gets);
+    assert_equal_s('r',f.mode?)
+#    assert_match(/Input$/,f.handled_by)
+
+    f = rio('qp/rwlines.txt').r!
+    assert_equal_s('r+',f.inputmode?)
+    f.puts("Line 0").puts("Line 1")
+#    assert_match(/InOut$/,f.puts("Line 0").puts("Line 1").handled_by)
+    assert_equal_s('r+',f.mode?)
+    assert_equal("Line 0\n",f.rewind.gets);
+#    assert_match(/InOut$/,f.handled_by)
+    assert_equal_s('r+',f.mode?)
+
+
+  end
+
+  def test_readwrite 
+    require 'rio'
+    tdir = rio(%w/qp test_readwrite/)
+    tdir.rmtree.mkpath.chdir {
+      exp = (0..5).to_a.map { |n| "Line #{n}" }
+
+      f = rio('rwlines.txt').chomp
+      0.upto(4) { |n| f.puts("Line #{n}") }
+      got =  f.a.puts("Line 5").readlines
+      assert_equal(exp,got)
+      
+      
+      f = rio('rwlines.txt').a
+      assert_equal_s('a',f.outputmode?)
+      f.puts("Line 0\n\n")
+#      assert_match(/Output$/,f.puts("Line 0\n\n").handled_by)
+      assert_equal_s('a',f.mode?)
+      assert_equal("Line 0\n",f.rewind.gets);
+      assert_equal_s('r',f.mode?)
+#      assert_match(/Input$/,f.handled_by)
+      
+      f = rio('rwlines.txt').a!
+      assert_equal_s('a+',f.outputmode?)
+      f.puts("Line 0\n\n")
+#      assert_match(/InOut$/,f.puts("Line 0\n\n").handled_by)
+      assert_equal_s('a+',f.mode?)
+      assert_equal("Line 0\n",f.rewind.gets);
+      assert_equal_s('a+',f.mode?)
+#      assert_match(/InOut$/,f.handled_by)
+      
+      f = rio('rwlines.txt').w
+      assert_equal_s('w',f.outputmode?)
+      f.puts("Line 0\n\n")
+#      assert_match(/Output$/,f.puts("Line 0\n\n").handled_by)
+      assert_equal_s('w',f.mode?)
+      assert_equal("Line 0\n",f.rewind.gets);
+      assert_equal_s('r',f.mode?)
+#      assert_match(/Input$/,f.handled_by)
+      
+      f = rio('rwlines.txt').w!
+      assert_equal_s('w+',f.outputmode?)
+      f.puts("Line 0").puts("Line 1")
+#      assert_match(/InOut$/,f.puts("Line 0").puts("Line 1").handled_by)
+      assert_equal_s('w+',f.mode?)
+      assert_equal("Line 0\n",f.rewind.gets);
+      assert_equal_s('w+',f.mode?)
+#      assert_match(/InOut$/,f.handled_by)
+
+      f = rio('rwlines.txt').r
+      assert_equal_s('r',f.inputmode?)
+      f.puts("Line 0").puts("Line 1")
+#      assert_match(/Output$/,f.puts("Line 0").puts("Line 1").handled_by)
+      assert_equal_s('w',f.mode?)
+      assert_equal("Line 0\n",f.rewind.gets);
+      assert_equal_s('r',f.mode?)
+#      assert_match(/Input$/,f.handled_by)
+
+      f = rio('rwlines.txt').r!
+      assert_equal_s('r+',f.inputmode?)
+      f.puts("Line 0").puts("Line 1")
+#      assert_match(/InOut$/,f.puts("Line 0").puts("Line 1").handled_by)
+      assert_equal_s('r+',f.mode?)
+      assert_equal("Line 0\n",f.rewind.gets);
+#      assert_match(/InOut$/,f.handled_by)
+      assert_equal_s('r+',f.mode?)
+    }
+  end
+  def test_copy2
+    require 'rio'
+    tdir = rio(%w/qp test_copy2/)
+    tdir.rmtree.mkpath.chdir {
+      txt = "Hello f1.txt"
+      o = rio('o').puts(txt).close
+      oslurp = o.contents
+
+      n = rio('n')
+      o.copy_to(n)
+      assert_equal(oslurp,n.contents)
+
+      d = rio('d1').rmtree.mkpath
+      n = rio(d,'o')
+      o.copy_to(d)
+      assert_equal(oslurp,n.contents)
+
+#      d = rio('d2').rmtree
+#      n = rio(d,'o')
+#      assert_raise(::RIO::Exception::Copy) {
+#        o.copy_to(n)
+#      }
+      
+
+      d = rio('d3').rmtree.mkpath
+      n = rio(d,'o').touch
+      o.copy_to(d)
+      assert_equal(oslurp,n.contents)
+
+
+      return unless $supports_symlink
+      d = rio('d5').rmtree.mkpath
+      q = rio(d,'qf').touch
+      d.chdir {
+        rio('qf').symlink('o')
+      }
+      n = rio(d,'o')
+      o.copy_to(d)
+      assert_equal(oslurp,n.contents)
+
+      d = rio('d6').rmtree.mkpath
+      q = rio(d,'qd').mkdir
+      d.chdir {
+        rio('qd').symlink('o')
+      }
+      n = rio(d,'o')
+
+
+
+
+    }
+  end
+  def smap(a) a.map { |el| el.to_s } end
+  def emap(d,a)
+    exp = a.map { |f| File.join(d,f) }.sort
+  end
+  def gmap(io)
+    smap(io.to_a).sort
+  end
+
+  def test_find
+    s_dir = 'qp/test_find'
+    dir =  RIO.cwd(s_dir).rmtree.mkpath
+    f1 = RIO.rio(dir,'f1.txt').puts("This is f1")
+    f2 = RIO.rio(dir,'f2.txt').puts("This is f2")
+    d2 = RIO.rio(dir,'d1','d2').mkpath
+    f3 = RIO.rio(dir,'d1','f3.txt').puts("This is f3")
+    f4 = d2.join('f4.emp').touch
+    
+    io = rio(s_dir)
+    exp = %w{f1.txt f2.txt d1}
+    assert_equal(emap(s_dir,exp), gmap(io))
+
+    io = rio(s_dir).files('*.txt')
+    exp = %w{f1.txt f2.txt}
+    assert_equal(emap(s_dir,exp), gmap(io))
+    
+    io = rio(s_dir).dirs
+    exp = %w{d1}
+    assert_equal(emap(s_dir,exp), gmap(io))
+    
+    io = rio(s_dir).all.dirs
+    exp = %w{d1 d1/d2}
+    assert_equal(emap(s_dir,exp), gmap(io))
+    
+    io = rio(s_dir).all.dirs("*2")
+    exp = %w{d1/d2}
+    assert_equal(emap(s_dir,exp), gmap(io))
+
+    io = rio(s_dir).all.files("*.emp")
+    exp = %w{d1/d2/f4.emp}
+    assert_equal(emap(s_dir,exp), gmap(io))
+
+
+
+
+  end
+  def test_mkdir
+    datadir = rio('qp/test_mkdir').rmtree.mkpath
+    dir2 = rio(datadir,'dir2').rmtree.mkpath
+    dir2 = rio(datadir,'dir2').rmtree.mkpath
+    #     sd1 > dir2
+    #     oline = rio(datadir,'dir1/sd1/f1.txt').readline
+    #     nline = rio(datadir,'dir2/sd1/f1.txt').readline
+    #     assert_equal(oline,nline)
+    
+    #     dir2 = rio(datadir,'dir2').rmtree.mkpath
+    #     dir2 < sd1
+    #     oline = rio(datadir,'dir1/sd1/f1.txt').readline
+    #     nline = rio(datadir,'dir2/sd1/f1.txt').readline
+    #     assert_equal(oline,nline)
+    
+  end
+  def test_specialio
+    tdir = rio(ttdir,'test_specialio').rmtree.mkpath
+    msg = "Hello File\n"
+    fname = 'f.txt'
+    rio(tdir,fname).puts(msg).close
+    str = rio(tdir,fname).readline
+    assert_equal(msg,str)
+    
+#    require 'open3'
+
+#    IO.popen("-") {|f| 
+#      if f.nil?
+#        rio(?-).puts('Hello Stdout')
+#      else
+#        assert_equal("Hello Stdout\n",f.gets)
+#      end
+#    }
+    
+    # For some reason the use of popen3 stopped working FIXME
+    #    stdin,stdout,stderr = Open3.popen3(%q~ruby -e "require 'rio';rio(?=).puts('Hello Stderr')"~)
+    #errput = stderr.gets
+    #assert_equal("Hello Stderr\n",errput)
+                 
+    smsg = str.sub(/File/,'StringIO')
+    srio = rio(?$).print(smsg)
+    assert_equal(smsg,srio.string)
+    # lines = rio('?').mode('w+').puts(str.sub(/File/,'Tempfile')).readlines
+    
+  end
+
+  def test_copy
+    require 'rio'
+    datadir = rio('qp/test_copy').rmtree.mkpath
+    inline = "Source Stuff\n"
+    src = rio(datadir,'src')
+    src.print(inline)
+    src.close
+    src = rio(datadir,'src')
+    dst1 = rio(datadir,'dst1')
+    src.copy_to(dst1)
+    dst2 = rio(datadir,'dst2').mkdir
+    src.copy_to(dst2)
+    sline = rio(datadir,'src').readline
+    l1 = rio(datadir,'dst1').readline
+    l2 = rio(datadir,'dst2/src').readline
+    assert_equal(inline,sline)
+    assert_equal(inline,l1)
+    assert_equal(inline,l2)
+
+    # copy directories
+    sd1 = rio(datadir,'dir1/sd1').rmtree.mkpath
+    txt = "Hello f1.txt"
+    sd1.join('f1.txt').puts(txt).close
+    oline = rio(datadir,'dir1/sd1/f1.txt').readline
+
+    dir2 = rio(datadir,'dir2').rmtree.mkpath
+    sd1.copy_to(dir2)
+    nline = rio(datadir,'dir2/sd1/f1.txt').readline
+    assert_equal(oline,nline)
+    
+  end
+  def cmpfiles(z1,z2)
+    o = rio(z1).contents
+    n = rio(z2).contents
+    o == n
+  end
+
+#   def test_dirstream
+#     datadir = rio('qp','test_dirstream').rmtree.mkpath
+#     rio(datadir,'afile').touch.symlink(rio(datadir,'asymlink'))
+#     rio(datadir,'adir').mkdir
+
+#     #pp datadir.open
+#     positions = {}
+#     while 1
+#       ps = datadir.tell
+#       ent = datadir.read
+#       break if ent.nil?
+#       positions[ent] = ps
+#     end
+    
+#     positions.each { |k,v|
+#       datadir.seek(v)
+#       ent = datadir.read
+#       assert_equal(k.to_s,ent.to_s)
+#     }
+#   end
+  def test_path
+    dir =  RIO.cwd(%w/qp test_path/).rmtree.mkpath
+    s_dir = 'qp/test_path'
+    assert_equal(true,::FileTest.directory?(s_dir))
+    f1 = RIO.rio(dir,'f1.txt').puts("This is f1")
+    assert_equal(true,::FileTest.file?(::File.join(s_dir,'f1.txt')))
+    f2 = RIO.rio(dir,'f2.txt').puts("This is f2")
+    assert_equal(true,::FileTest.file?(::File.join(s_dir,'f2.txt')))
+    f3 = RIO.rio(dir,'d1').mkpath.join('f3.txt').puts("This is f2")
+    assert_equal(true,::FileTest.directory?(::File.join(s_dir,'d1')))
+    assert_equal(true,::FileTest.file?(::File.join(s_dir,'d1/f3.txt')))
+    f4 = RIO.rio(dir,'d1').mkpath.join('f4.emp').touch
+    assert_equal(0,::FileTest.size(::File.join(s_dir,'d1/f4.emp')))
+  end
+  def test_glob
+  end
+
+  def test_sdio
+    
+    #    qpd = rio(%w/qp/).mkpath
+    #    rio(qpd,'hw.txt').puts("This\nis\na\nqesi")
+    #    ObjectSpace.each_object(File)    { |o|
+    #      p o.to_s
+    #    }
+
+    
+    #    io = rio(qpd,'hw.txt').readlines
+    #    p io.inspect
+  end
+end
+#     extend Forwardable
+#     def_instance_delegators(:state,
+#                             :to_i,
+#                             :mode,
+#                             :mkdir,:mkpath,
+#                             :rmdir,:rmtree,
+#                             :chdir,
+#                             :each_entry,:each_line,:each,:each_byte,
+#                             :each_tested,:each_file,:each_directory,:each_symlink,
+#                             :to_str,:to_a,:contents,
+#                             :length,:size,:zero?,
+#                             :eof?,
+#                             :read,:readchar,:readline,:readlines,
+#                             :putc,:puts,:print,:printf,
+#                             :chomp,:chop,
+#                             :atime,:ctime,:mtime,
+#                             :blockdev?,:chardev?,:pipe?,:socket?,:symlink?,:sticky?,
+#                             :dir?,:directory?,:file?,:exist?,
+#                             :executable?,:executable_real?,
+#                             :readable?,:readable_real?,:writeable?,:writeable_real?,
+#                             :grpowned?,:owned?,:setgid?,:setuid?,
+#                             :ftype,:extname,
+#                             :lstat,:stat,
+#                             :fnmatch?)
+# class LogDecorator
+#   def initialize(target)
+#     @target = target
+#   end
+#   def method_missing( sym, *args )
+#     call = "#{@target}.#{sym}(" + (args.map {|a|a.inspect}).join(",") + ")"
+#     puts "calling #{call}"
+#     result = @target.__send__( sym, *args )
+#     puts "returned #{result.inspect} from #{call}"
+#     result
+#   end
+# end
+
+#module RIO
+#  module RIOState
+#    def new_rio(*args)
+#      self.class.new(*args)
+#    end
+#  end
+#end # module RIO