rio 0.3.1

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/methods.rb

@@ -0,0 +1,185 @@
+#!/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_methods < Test::Unit::TestCase
+  def assert!(a,msg="negative assertion")
+    assert((!(a)),msg)
+  end
+
+  def check_clone(ios)
+    oexp = []
+    cexp = []
+
+    oexp << ios.gets
+    ioc = ios.clone
+
+    cexp << ioc.gets
+    oexp << ios.gets
+    until ioc.eof?
+      cexp << ioc.gets
+    end
+
+    until ios.eof?
+      oexp << ios.gets
+    end
+    return ioc,oexp,cexp
+  end
+
+  def check_dup(ios)
+    oexp = []
+    cexp = []
+
+    oexp << ios.gets
+    ioc = ios.dup
+    assert_not_nil(ioc,"dup returns nil")
+    cexp << ioc.gets
+    oexp << ios.gets
+    until ioc.eof?
+      cexp << ioc.gets
+    end
+
+    until ios.eof?
+      oexp << ios.gets
+    end
+    return ioc,oexp,cexp
+  end
+
+  def check_clone_close(ios,ioc)
+    assert!(ios.closed?,"original not closed")
+    assert!(ioc.closed?,"clone not closed")
+    ioc.close
+    assert(ioc.closed?,"clone closed?")
+    assert!(ios.closed?," orignal still not closed?")
+    ios.close
+    assert(ios.closed?,"now original closed")
+  end
+
+  def check_dup_close(ios,ioc)
+    assert!(ios.closed?,"original not closed")
+    assert(ioc.closed?,"dup closed")
+    ios.close
+    assert(ios.closed?,"now original closed")
+  end
+  def setup
+    @cwd = rio(::Dir.getwd)
+    @dir = rio('qp/methods')
+#    $trace_states = true
+    @dir.mkpath.chdir
+    @lines = (0..5).map { |n| "Line#{n}" }
+    @chlines = @lines.map(&:chomp)
+    ::File.open('lines','w') do |f|
+      @lines.each do |li|
+        f.puts(li)
+      end
+    end
+    @lines = rio('lines').to_a
+  end
+  def teardown
+    @cwd.chdir
+  end
+
+  def test_clone_like_IO
+
+    ios = ::File.open('lines')
+    ioc,oexp,cexp = check_clone(ios)
+    check_clone_close(ios,ioc)
+    ioc.close unless ioc.closed?
+    ios.close unless ios.closed?
+
+    ario = rio('lines').nocloseoneof
+    crio,oans,cans = check_clone(ario)
+    assert_equal(oexp,oans)
+    assert_equal(cexp,cans)
+    check_clone_close(ario,crio)
+
+  end
+
+  def test_dup_not_like_IO
+
+    ios = ::File.open('lines')
+    ioc,oexp,cexp = check_dup(ios)
+    check_clone_close(ios,ioc)
+    ario = rio('lines').nocloseoneof
+    crio,oans,cans = check_dup(ario)
+    assert_equal(@lines,oans)
+    assert_equal(@lines,cans)
+    check_dup_close(ario,crio)
+
+  end
+
+
+  def test_clone_own_context
+
+    assert(rio.closeoncopy?,"closeoncopy is on")
+    assert!(rio.nocloseoncopy.closeoncopy?,"nocloseoncopy is off")
+    assert!(rio.chomp?,"chomp is off")
+    chomper = rio.chomp
+    assert(chomper.chomp?,"chomp is on")
+    cl = chomper.clone
+    assert(cl.chomp?,"cloned chomp is on")
+    cl.nochomp
+    assert!(cl.chomp?,"cloned chomp is off")
+    assert(chomper.chomp?,"original chomp is still on")
+
+    chomper.join!('lines')
+    ans = chomper.to_a
+    assert_equal(@chlines,ans)
+
+    cl.join!('lines')
+    ans = cl.to_a
+    assert_equal(@lines,ans)
+
+  end
+  def ztest_clone_read_ruby
+
+    #$trace_states = true
+    afile = ::File.open('lines')
+    arec = afile.gets
+    assert_equal(@lines[0],arec)
+    cfile = afile.dup
+    #p "POS: a(#{afile.pos}) c(#{cfile.pos})"
+    crec = cfile.gets
+    #p "crec=#{crec} POS: a(#{afile.pos}) cfile(#{cfile.pos})"
+    afile.close
+  end
+  def test_clone_read
+    return unless $supports_symlink
+    #$trace_states = true
+    ario = rio('lines')
+    arec = ario.getrec
+    assert_equal(@lines[0],arec)
+    #$trace_states = true
+    crio = ario.clone.chomp
+    #p "POS: ario(#{ario.pos}) crio(#{crio.pos})"
+    crec = crio.getrec
+    #p "crec=#{crec} POS: ario(#{ario.pos}) crio(#{crio.pos})"
+
+    assert_equal(@chlines[1],crec)
+
+    arec = ario.getrec
+    #$trace_states = false
+    assert_equal(@lines[1],arec)
+    cremaining = crio.to_a
+
+    assert_equal(@chlines[2...@lines.size],cremaining)
+    #p "#{crio.eof?} #{crio.closed?}"
+    assert(crio.eof?,"clone eof?") unless crio.closed?
+    assert(crio.closed?,"clone closed?")
+
+    assert!(ario.eof?,"orignal eof?") unless ario.closed?
+    assert!(ario.closed?,"original closed?")
+
+    aremaining = ario.readlines
+    assert_equal(@lines[2...@lines.size],aremaining)
+    assert(ario.eof?,"orignal eof?") unless ario.closed?
+    assert(ario.closed?,"original closed?")
+
+  end
+
+end

data/test/tc/misc.rb

@@ -0,0 +1,473 @@
+#!/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'
+require 'tc/testcase'
+
+#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').nocloseoneof.autorewind.chomp.mode('w+')
+    0.upto(4) do |n|
+      f.puts("Line #{n}")
+    end
+    got = f.puts("Line 5").readlines
+    assert_equal(exp,got)
+
+    f = rio('qp/rwlines.txt').nocloseoneof.autorewind.chomp.mode('w+')
+    0.upto(4) do |n|
+      f.puts("Line #{n}")
+    end
+    got = f.puts!("line 5").readlines
+    assert_equal([],got)
+
+    f = rio('qp/rwlines.txt').nocloseoneof.autorewind.chomp.mode('w+')
+    0.upto(4) do |n|
+      f.puts("Line #{n}")
+    end
+    f.close
+    got = rio('qp/rwlines.txt').a.nocloseoneof.autorewind.chomp.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').nocloseoneof.autorewind.chomp.mode('w+')
+      0.upto(4) { |n| f.puts("Line #{n}") }
+      got = f.puts("Line 5").readlines
+      assert_equal(exp,got)
+      
+      f = rio('rwlines.txt').nocloseoneof.autorewind.chomp.mode('w+')
+      0.upto(4) { |n| f.puts("Line #{n}") }
+      got = f.puts!("line 5").readlines
+      assert_equal([],got)
+      
+      f = rio('rwlines.txt').nocloseoneof.autorewind.chomp.mode('w+')
+      0.upto(4) { |n| f.puts("Line #{n}") }
+      f.close
+      got = rio('rwlines.txt').a.nocloseoneof.autorewind.chomp.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.slurp
+
+      n = rio('n')
+      o.copy(n)
+      assert_equal(oslurp,n.slurp)
+
+      d = rio('d1').rmtree.mkpath
+      n = rio(d,'o')
+      o.copy(d)
+      assert_equal(oslurp,n.slurp)
+
+#      d = rio('d2').rmtree
+#      n = rio(d,'o')
+#      assert_raise(::RIO::Exception::Copy) {
+#        o.copy(n)
+#      }
+      
+
+      d = rio('d3').rmtree.mkpath
+      n = rio(d,'o').touch
+      o.copy(d)
+      assert_equal(oslurp,n.slurp)
+
+
+      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(d)
+      assert_equal(oslurp,n.slurp)
+
+      d = rio('d6').rmtree.mkpath
+      q = rio(d,'qd').mkdir
+      d.chdir {
+        rio('qd').symlink('o')
+      }
+      n = rio(d,'o')
+
+
+
+
+    }
+  end
+  require 'extensions/symbol'
+  def pa(a) p a.map( &:to_s ) end
+  def smap(a) a.map( &: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
+    return unless $supports_symlink
+    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(dst1)
+    dst2 = rio(datadir,'dst2').mkdir
+    src.copy(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(dir2)
+    nline = rio(datadir,'dir2/sd1/f1.txt').readline
+    assert_equal(oline,nline)
+    
+  end
+  def cmpfiles(z1,z2)
+    o = rio(z1).slurp
+    n = rio(z2).slurp
+    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,:slurp,
+#                             :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