wishdev-rio 0.4.3.1

data/test/tc/base.rb

@@ -0,0 +1,31 @@
+#!/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_base < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+  end
+  def test_basic
+    r = rio('zippy',{:base => '/'})
+    assert_equal('/zippy',r.abs.path)
+  end
+  def test_2args
+    r = rio('tmp','zippy',{:base => '/'})
+    assert_equal('/tmp/zippy',r.abs.path)
+  end
+  def test_longer_base
+    r = rio('zippy',{:base => '/tmp/'})
+    assert_equal('/tmp/zippy',r.abs.path)
+  end
+end

data/test/tc/base2.rb

@@ -0,0 +1,87 @@
+#!/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_base2 < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+    @base_urls = {
+      'abshttp' => 'http://localhost/riotest/dir/index.html',
+      'rootdir' => '/rootdir/dir/',
+      'reldir'   => 'reldir/dir/',
+    }
+    @links = {
+      'abshttp' => 'http://localhost/riotest/hw.html',
+      'relfile' => '../hw.html',
+      'absfile' => '/riotest/hw.html',
+    }
+  end
+
+  def test_abshttp_absfile
+    bk = 'abshttp'
+    lk = 'absfile'
+    b = @base_urls[bk]
+    l = @links[lk]
+    exp = [l,l,l,@links['abshttp'],l,b,@links['abshttp']]
+    run_case(bk,lk,exp)
+  end
+  def run_case(bk,lk,exp)
+    bs = @base_urls[bk]
+    ls = @links[lk]
+
+    [bs,URI(bs)].each do |b|
+      [ls,URI(ls),rio(ls)].each do |l|
+        u = rio(ls)
+        msg = mkmsg(bk,lk,b,l)
+        assert_equal(exp[0].to_s,u.to_s,msg)
+        assert_equal(exp[1].to_s,u.base.to_s,msg)
+        assert_equal(exp[2].to_s,u.abs.to_s,msg)
+        #p "run_case: b=#{b} abs=#{u.abs(b)}"
+        assert_equal(exp[3].to_s,u.abs(b).to_s,msg)
+      end
+    end
+
+
+    [bs,URI(bs)].each do |b|
+      [ls,URI(ls),rio(ls)].each do |l|
+        #p "b=#{b.inspect} l=#{l.inspect}"
+        u = rio(l,{:base => b})
+        msg = mkmsg(bk,lk,b,l)
+        assert_equal(exp[4].to_s,u.to_s,msg)
+        assert_equal(exp[5].to_s,u.base.to_s,msg)
+        assert_equal(exp[6].to_s,u.abs.to_s,msg)
+      end
+    end
+  end
+  def test_abshttp_relfile
+    bk = 'abshttp'
+    lk = 'relfile'
+    b = @base_urls[bk]
+    l = @links[lk]
+    wd = ::Dir.getwd+'/'
+    abs = ::Pathname.new(wd + l).cleanpath
+    exp = [l,wd,abs,@links['abshttp'],l,b,@links['abshttp']]
+    run_case(bk,lk,exp)
+  end
+  def test_abshttp_abshttp
+    bk = 'abshttp'
+    lk = 'abshttp'
+    b = @base_urls[bk]
+    l = @links[lk]
+    exp = [l,l,l,l,l,b,l]
+    run_case(bk,lk,exp)
+  end
+  def mkmsg(basekey,linkkey,base,link)
+    "Base[#{basekey}](#{base.class}) Link[#{linkkey}](#{link.class})"
+  end
+end

data/test/tc/cd1.rb

@@ -0,0 +1,113 @@
+#!/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_cd1 < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    rio('d0').rmtree.mkpath
+    rio('d0/d2').rmtree.mkpath
+    rio('d0/d3').rmtree.mkpath
+    rio('d0/d4').rmtree.mkpath
+    rio('d0/d2/d3').rmtree.mkpath
+    rio('d0/d2/d5').rmtree.mkpath
+    rio('d0/d3/d6').rmtree.mkpath
+    rio('d1').rmtree.mkpath
+    rio('d1/d8').rmtree.mkpath
+    make_lines_file(1,'d1/f0')
+    make_lines_file(2,'d1/f1')
+    make_lines_file(1,'d0/f0')
+    make_lines_file(2,'d0/f1')
+    make_lines_file(1,'d0/d2/f0')
+    make_lines_file(2,'d0/d2/f1')
+    make_lines_file(1,'d0/d3/d6/f0')
+    make_lines_file(2,'d0/d3/d6/f1')
+  end
+  def setup
+    super
+    self.class.once unless @@once
+
+    @d0 = rio('d0')
+    @d1 = rio('d1')
+    @d2 = rio('d0/d2')
+    @f0 = rio('d0/f0')
+    @f1 = rio('d0/f1')
+    @f2 = rio('d0/d2/f2')
+    @f3 = rio('d0/d2/f3')
+  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")
+      case
+      when ent.file?
+        assert(ds.file?,"entry is a file")
+        assert_equal(ent[],ds[],"file has same contents")
+      when ent.dir?
+        assert_dirs_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def assert_skel_equal(exp,d,msg="")
+    exp.each do |ent|
+      next unless ent.dir?
+      ds = rio(d,ent.filename)
+      assert(ds.exist?,"entry '#{ds}' exists")
+      assert_equal(ent.ftype,ds.ftype,"same ftype")
+      case
+      when ent.dir?
+        assert_skel_equal(ent,ds,"subdirectories are the same")
+      end
+    end
+  end
+  def test_d2a
+    src = rio(@d1)
+    dst = []
+#    dst < src
+    #$trace_states = true
+    src > dst
+    $trace_states = false
+    p smap(src[])
+    p smap(dst.inspect)
+
+  end
+  def test_d2b
+    src = rio(@d1)
+    dst = []
+#    dst < src
+    #$trace_states = true
+    src.each do |e|
+      dst << e
+    end
+    $trace_states = false
+    p smap(src[])
+    p smap(dst.inspect)
+
+  end
+  def a0test_nonex
+    dst = rio('nonex').delete!
+    assert!(dst.exist?)
+    src = rio(@d1)
+#    dst < src
+    #$trace_states = true
+    src > dst
+    $trace_states = false
+#    p smap(dst.all[].map { |e| e.rel(dst) })
+    #p smap(src.all[])
+    #p smap(dst.all[])
+#    assert_dirs_equal(@d0,rio(dst,@d0.filename),"basic copy")
+#    exp = @d0.files[]
+#    dd = rio(dst,@d0.filename)
+#    ans = dd.map { |e| e.rel(dst) }
+#    p smap(exp)
+#    p smap(ans)
+#    assert_array_equal(exp,ans,"copy files only")
+  end
+end

data/test/tc/clearsel.rb

@@ -0,0 +1,68 @@
+#!/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_clearsel < Test::Unit::TestCase
+  def tdir() rio(%w/qp clearsel/) 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
+    @cwd = ::Dir.getwd
+    tdir.mkpath.chdir
+  end
+  def teardown
+    ::Dir.chdir @cwd
+  end
+
+  def test_basic
+    rio('a').delete!.mkpath.chdir
+
+    file = mkalinesfile(8,'f1')
+    lines = file[]
+    cmnt_range = (2..4)
+    cmnt_range.each do |n|
+      lines[n] = '#' + lines[n]
+    end
+    (0..3).each do |n|
+      lines[n].sub!(/f1/,'f2')
+    end
+    file < lines
+
+    f0 = file.dup
+    begin
+      exp = lines[cmnt_range]
+      ans = f0.lines[/^\s*#/]
+      assert_equal(exp,ans)
+      ans = f0[0]
+      assert_equal(lines[0..0],f0[0])
+      assert_equal(lines,f0[])
+      assert_equal(lines[1..2],f0[1..2])
+      assert_equal(lines,f0.lines(1..2)[])
+      assert_equal(lines[4..4],f0.lines(1..2)[4])
+
+    end
+
+
+    file.close
+    rio('..').chdir
+  end
+end

data/test/tc/clone.rb

@@ -0,0 +1,208 @@
+#!/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_clone < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+  end
+  def setup
+    super
+    self.class.once unless @@once
+    @lines = (0..8).map { |n| "Line#{n}" }
+    @chlines = @lines.map{|el| el.chomp}
+    ::File.open('lines1','w') do |f|
+      @lines.each do |li|
+        f.puts(li)
+      end
+    end
+    ::File.open('lines2','w') do |f|
+      @lines.each do |li|
+        f.puts(li)
+      end
+    end
+    @lines = rio('lines1').to_a
+  end
+
+
+  def check_clone(ios)
+    oexp = []
+    cexp = []
+
+    oexp << ios.gets
+    ioc = ios.clone
+
+    cexp << ioc.gets
+    oexp << ios.gets
+    while ans = ioc.gets
+      cexp << ans
+    end
+
+    while ans = ios.gets
+      oexp << ans
+    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
+    while ans = ioc.gets
+      cexp << ans
+    end
+
+    while ans = ios.gets
+      oexp << ans
+    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 test_clone_closes_like_IO
+    ios = ::File.open('lines1')
+    ioc,oexp,cexp = check_clone(ios)
+    check_clone_close(ios,ioc)
+    ioc.close unless ioc.closed?
+    ios.close unless ios.closed?
+
+    ario = rio('lines1').nocloseoneof
+    crio,oans,cans = check_clone(ario)
+    assert_equal(oexp,oans)
+    assert_equal(cexp,cans)
+    check_clone_close(ario,crio)
+
+  end
+
+  def test_dup_doesnt_close_like_IO
+
+    ios = ::File.open('lines1')
+    ioc,oexp,cexp = check_dup(ios)
+    check_clone_close(ios,ioc)
+    ario = rio('lines1').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!('lines1')
+    ans = chomper.to_a
+    assert_equal(@chlines,ans)
+
+    cl.join!('lines1')
+    ans = cl.to_a
+    assert_equal(@lines,ans)
+
+  end
+  def test_read_moves_pos_like_IO
+    #$trace_states = true
+    fnio = ::File.open('lines1')
+    frio = rio('lines2')
+    assert_equal(fnio.pos,frio.pos)
+
+    nrec = fnio.gets
+    rrec = frio.gets
+    assert_equal(nrec,rrec)
+    assert_equal(fnio.pos,frio.pos)
+
+    cfnio = fnio.clone
+    cfrio = frio.clone
+    assert_equal(cfnio.pos,cfrio.pos)
+    assert_equal(fnio.pos,frio.pos)
+    nrec = cfnio.gets
+    rrec = cfrio.gets
+    assert_equal(nrec,rrec)
+    assert_equal(cfnio.pos,cfrio.pos)
+    assert_equal(fnio.pos,frio.pos)
+
+    nrec = cfnio.gets
+    rrec = cfrio.gets
+
+    assert_equal(nrec,rrec)
+    assert_equal(cfnio.pos,cfrio.pos)
+    assert_equal(fnio.pos,frio.pos)
+
+    nrec = fnio.gets
+    rrec = frio.gets
+    assert_equal(nrec,rrec)
+    #assert_equal(fnio.pos,frio.pos)
+
+  end
+
+  def test_clone_read_ruby
+
+    #$trace_states = true
+    afile = ::File.open('lines1')
+    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
+    ario = rio('lines1')
+    arec = ario.getrec
+    assert_equal(@lines[0],arec)
+    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
+    cremaining = crio.to_a
+
+    assert_equal(@chlines[2...@lines.size],cremaining)
+    #p "#{crio.eof?} #{crio.closed?}"
+    #$trace_states = true
+    assert(crio.eof?,"clone eof?") unless crio.closed?
+    assert(crio.closed?,"clone closed?")
+
+  end
+
+end