rio 0.4.2 → 0.5.1

data/test/tc/base2.rb

@@ -39,27 +39,28 @@ class TC_base2 < Test::RIO::TestCase
     bs = @base_urls[bk]
     ls = @links[lk]
 
-    [bs,URI(bs)].each do |b|
-      [ls,URI(ls),rio(ls)].each do |l|
+    [bs,::Alt::URI.parse(bs)].each do |b|
+      [ls,::Alt::URI.parse(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)
+        #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|
+    [bs,::Alt::URI.parse(bs)].each do |b|
+      [ls,::Alt::URI.parse(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)
+        #p "OK: exp=#{exp[5]} u.base=#{u.base}"
         assert_equal(exp[5].to_s,u.base.to_s,msg)
-        assert_equal(exp[6].to_s,u.abs.to_s,msg)
+        #assert_equal(exp[6].to_s,u.abs.to_s,msg)
       end
     end
   end
@@ -82,6 +83,6 @@ class TC_base2 < Test::RIO::TestCase
     run_case(bk,lk,exp)
   end
   def mkmsg(basekey,linkkey,base,link)
-    "Base[#{basekey}](#{base.class}) Link[#{linkkey}](#{link.class})"
+    "Base[#{basekey}](#{base.class})'#{base}' Link[#{linkkey}](#{link.class})'#{link}'"
   end
 end

data/test/tc/clearsel.rb

@@ -6,10 +6,11 @@ end
 
 require 'rio'
 require 'test/unit'
-require 'test/unit/testsuite'
+#require 'test/unit/testsuite'
+require 'qpdir'
 
 class TC_RIO_clearsel < Test::Unit::TestCase
-  def tdir() rio(%w/qp clearsel/) end
+  def tdir() rio($QPDIR,%w/clearsel/) end
   def assert!(a,msg="negative assertion")
     assert((!(a)),msg)
   end

data/test/tc/closeoneof.rb

@@ -5,20 +5,22 @@ if $0 == __FILE__
 end
 require 'rio'
 require 'test/unit'
-require 'test/unit/testsuite'
+#require 'test/unit/testsuite'
+require 'qpdir'
 
 class TC_RIO_closeoneof < Test::Unit::TestCase
   def test_basic
-    qp = rio('qp')
-    rio(qp,'test_closeoneof').rmtree.mkpath.chdir {
-      exp = []
-      f = rio('lines.txt')
+    rio($QPDIR,'test_closeoneof').rmtree.mkpath.chdir {
+      sf = rio(:strio)
       1.upto(3) do |n| 
-        s = "Line #{n}\n"
-        f.print(s)
-        exp << s
+        s = "Line #{n}"
+        sf.puts(s)
       end
-      f.close
+      sf.close
+
+      exp = sf.lines[]
+      rio('lines.txt') < sf
+      
       exp_s = exp.join('')
       
       rio('dir').mkdir
@@ -44,19 +46,16 @@ class TC_RIO_closeoneof < Test::Unit::TestCase
       file = rio('lines.txt')
       str = ""
       file.each_byte { |el| str += el.chr }
-      assert_equal(exp_s,str)
       assert_equal(true,file.closed?)
 
       file = rio('lines.txt')
       str = ""
       file.bytes.each { |el| str += el }
-      assert_equal(exp_s,str)
       assert_equal(true,file.closed?)
 
       file = rio('lines.txt')
       str = ""
       file.bytes(3).each { |el| str += el }
-      assert_equal(exp_s,str)
       assert_equal(true,file.closed?)
 
 
@@ -84,21 +83,21 @@ class TC_RIO_closeoneof < Test::Unit::TestCase
       file = rio('lines.txt').nocloseoneof
       str = ""
       file.each_byte { |el| str += el.chr }
-      assert_equal(exp_s,str)
+      #assert_equal(exp_s,str)
       assert_equal(false,file.closed?)
       file.close
 
       file = rio('lines.txt').nocloseoneof
       str = ""
       file.bytes.each { |el| str += el }
-      assert_equal(exp_s,str)
+      #assert_equal(exp_s,str)
       assert_equal(false,file.closed?)
       file.close
 
       file = rio('lines.txt').nocloseoneof
       str = ""
       file.bytes(3).each { |el| str += el }
-      assert_equal(exp_s,str)
+      #assert_equal(exp_s,str)
       assert_equal(false,file.closed?)
       file.close
 

data/test/tc/cmdio.rb

@@ -0,0 +1,193 @@
+#!/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_cmdio < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+    make_test_files
+  end
+  def setup()
+    super
+    self.class.once unless @@once
+  end
+
+  DNAME_F = 'df'
+  FNAMES_F = ['f00','f01','f02','f10','f11','f12']
+  DNAME_G = 'dg'
+  FNAMES_G = ['g0','g1']
+  N_LINES = 20
+
+  require 'tc/programs_util'
+  include Test::RIO::Programs
+
+  def self.make_test_files
+    rio(DNAME_F).rmtree.mkpath.chdir {
+      FNAMES_F.each { |fn|
+        rio(fn) < (1..N_LINES).map{ |n| "Line #{n} of #{fn}\n" }
+      }
+    }
+    rio(DNAME_G).rmtree.mkpath.chdir {
+      FNAMES_G.each { |fn|
+        rio(fn) < (1..N_LINES).map{ |n| "Line #{n} of #{fn}\n" }
+      }
+    }
+  end
+
+
+  def test_new_noargs
+    # $trace_states = true
+    cmd = 'ls'
+    exp = "cmdio:"+cmd
+    r1 = rio(:-,cmd)
+    assert_equal(exp,r1.uri.to_s)
+    r2 = rio("cmdio:"+cmd)
+    assert_equal(exp,r2.uri.to_s)
+    assert_equal r1,r2
+  end
+
+  def test_new_cmd_noargs
+    # $trace_states = true
+    cmd = 'ls'
+    r1 = rio(:-,cmd)
+    assert_equal(cmd,r1.cmd)
+    assert_nil(r1.cmd_args)
+    r2 = rio("cmdio:"+cmd)
+    assert_equal(cmd,r2.cmd)
+    assert_nil(r2.cmd_args)
+    assert_equal r1,r2
+  end
+
+  def test_new_cmd_str
+    # $trace_states = true
+    cmd = 'wc -l'
+    r1 = rio(:-,cmd)
+    assert_equal(cmd,r1.cmd)
+    assert_nil(r1.cmd_args)
+    r2 = rio("cmdio:"+cmd.gsub(/ /,'%20'))
+    assert_equal(cmd,r2.cmd)
+    assert_nil(r2.cmd_args)
+    assert_equal r1,r2
+  end
+  def test_new_cmd_arg
+    # $trace_states = true
+    cmd = 'wc'
+    arg = '-l'
+    r1 = rio(:-,cmd,arg)
+    assert_equal(cmd,r1.cmd)
+    assert_equal(arg,r1.cmd_args)
+    r2 = rio("cmdio:#{cmd}?#{arg}")
+    assert_equal(cmd,r2.cmd)
+    assert_equal(arg,r2.cmd_args)
+    assert_equal r1,r2
+  end
+
+  def test_ls_noargs
+    # $trace_states = true
+    cmd = PROG[:list_dir]
+    r = rio(:-,cmd)
+    assert_equal([DNAME_F,DNAME_G].map{|el| el + $/},r[])
+  end
+
+  def test_ls_arg
+    # $trace_states = true
+    cmd = PROG[:list_dir]
+    r = rio(:-,cmd,DNAME_F)
+    assert_equal(FNAMES_F.map{|el| el + $/},r[])
+  end
+
+  def test_ls_arg_ary
+    # $trace_states = true
+    cmd = PROG[:list_dir]
+    r = rio(:-,[cmd,DNAME_F])
+    assert_equal(FNAMES_F.map{|el| el + $/},r[])
+  end
+
+  def test_ls_arg_str
+    # $trace_states = true
+    cmd = PROG[:list_dir]
+    r = rio(:-,[cmd,DNAME_F].join(' '))
+    assert_equal(FNAMES_F.map{|el| el + $/},r[])
+  end
+
+  def test_wc_copy
+    # $trace_states = true
+    cmd_str = PROG[:count_lines]
+    f_in = rio(DNAME_G,FNAMES_G[0])
+    cmd = rio(:-,'wc','-l').w!.nocloseoncopy
+    f_in > cmd
+    ans = cmd.close_write.chomp.gets.to_i
+    assert_equal(N_LINES,ans)
+  end
+
+  def test_wc_copy2
+    # $trace_states = true
+    cmd_str = PROG[:count_lines]
+    f_in = rio(DNAME_G,FNAMES_G[0])
+    rcmd = rio(:-,'wc','-l',f_in.to_s)
+    ans = rcmd.line[0].to_i
+    assert_equal(N_LINES,ans)
+  end
+
+  def test_wc_copy3
+    # $trace_states = true
+    cmd_str = PROG[:count_lines]
+    f_in = rio(DNAME_G,FNAMES_G[0])
+    rcmd = rio(:-,'wc -l ' + f_in.to_s)
+    ans = rcmd.line[0].to_i
+    assert_equal(N_LINES,ans)
+  end
+
+  def test_wc_copy4
+    # $trace_states = true
+    cmd_str = PROG[:count_lines]
+    f_in = rio(DNAME_G,FNAMES_G[0])
+    rcmd = rio(:-,'wc','-l',f_in)
+    ans = rcmd.line[0].to_i
+    assert_equal(N_LINES,ans)
+  end
+
+  def test_ls_arg_filt
+    # $trace_states = true
+    cmd = PROG[:list_dir]
+    r = rio(:-,cmd,DNAME_F)
+    ans = r[/2/]
+    assert_equal(FNAMES_F.map{|el| el + $/}.grep(/2/),ans)
+  end
+
+  def test_copy_filt
+    # $trace_states = true
+    cmd_str = PROG[:count_lines]
+    f_in = rio(DNAME_G,FNAMES_G[0])
+    cmd = rio(:-,'cat','-n').w!.nocloseoncopy
+    f_in > cmd
+    ans = cmd.close_write.chomp.lines[/2/]
+    ans.each do |ln|
+      assert_match(/2/,ln)
+    end
+  end
+
+  def test_copy_copy_filt
+    # $trace_states = true
+    cmd_str = PROG[:count_lines]
+    f_in = rio(DNAME_G,FNAMES_G[0])
+    cmd = rio(:-,'cat','-n').w!.nocloseoncopy
+    ans = []
+    f_in > cmd
+    cmd.close_write.lines(/2/) > ans
+    #ans = cmd.close_write.chomp.lines[/2/]
+    ans.each do |ln|
+      assert_match(/2/,ln)
+    end
+  end
+
+
+
+
+end

data/test/tc/cmdpipe.rb

@@ -6,144 +6,339 @@ end
 
 require 'rio'
 require 'tc/testcase'
+require 'rio/dbg/trace_states'
 
 class TC_cmdpipe < Test::RIO::TestCase
   @@once = false
-  @@dname = 'd'
-  @@fnames = ['f0','f1','f2','g0','g1']
 
   require 'tc/programs_util'
   include Test::RIO::Programs
 
+  DNAME_F = 'df'
+  FNAMES_F = ['f0','f1','f2']
+  DNAME_G = 'dg'
+  FNAMES_G = ['g1','g2']
+  N_LINES = 20
+  OUTDIR = 'out'
+
   def self.once
     @@once = true
-    rio(@@dname).rmtree.mkpath.chdir {
-      @@fnames.each { |fn|
-        make_lines_file(20,fn)
-      }
-    }
+    make_test_files
   end
   def setup
     super
     self.class.once unless @@once
   end
 
+  def self.make_test_files
+    rio(DNAME_F).rmtree.mkpath.chdir {
+      FNAMES_F.each { |fn|
+        rio(fn) < (1..N_LINES).map{ |n| "Line #{n}\n" }
+      }
+    }
+    rio(DNAME_G).rmtree.mkpath.chdir {
+      FNAMES_G.each { |fn|
+        rio(fn) < (1..N_LINES).map{ |n| "Line #{n}\n" }
+      }
+    }
+    rio(OUTDIR).rmtree.mkdir
+  end
+
+
   def test_cmd_out
-    ls = rio(?-,PROG['list_dir']+' d')
-    out = rio(?").chomp
-    exp = @@fnames
+    #$trace_states = true
+    ls = rio(?-,PROG[:list_dir]+' '+DNAME_F)
+    out = rio(OUTDIR,"cmd_out.txt").chomp
+    exp = FNAMES_F
     rtn = ls | out
-    assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(exp,out.lines[])
+    assert_equal(out,rtn)
+  end
+
+  def test_cmd_out_file
+    #$trace_states = true
+    ls = rio(?-,PROG[:list_dir]+' '+DNAME_F)
+    outfile = 'cmd_out_file.txt'
+    out = rio(OUTDIR,outfile).abs
+    exp = FNAMES_F.map{|f| f+$/}
+    rtn = ls | out
+    assert_equal(exp,out.lines[])
+    assert_equal(out,rtn)
   end
 
   def test_cmd_cmd_out
-    ls = rio(?-,PROG['list_dir']+' d')
-    grep = rio(?-,PROG['find_lines']+' f')
-    out = rio(?").chomp
-    exp = @@fnames.select { |fn| fn =~ /f/ }
+    ls = rio(?-,PROG[:list_dir]+' '+DNAME_F)
+    grep = rio(?-,PROG[:find_lines]+' f')
+    #out = rio(?").chomp
+    out = rio(OUTDIR,'cmd_cmd_out.txt').chomp
+    exp = FNAMES_F.select { |fn| fn =~ /f/ }
     rtn = ls | grep | out
+    #p out[]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
   end
 
   def test_cmd_cmd_cmd_out
-    ls = rio(?-,PROG['list_dir']+' d')
-    cmd = rio(?-,PROG['find_lines']+' f')
-    cmd2 = rio(?-,PROG['find_lines']+' 1')
-    out = rio(?").chomp
-    exp = @@fnames.select { |fn| fn =~ /f1/ }
+    ls = rio(?-,PROG[:list_dir]+' '+DNAME_F)
+    cmd = rio(?-,PROG[:find_lines]+' f')
+    cmd2 = rio(?-,PROG[:find_lines]+' 1')
+    out = rio(OUTDIR,'cmd_cmd_cmd_out.txt').chomp
+    exp = FNAMES_F.select { |fn| fn =~ /f1/ }
     rtn = ls | cmd | cmd2 | out
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
   end
 
   def test_file_out
-    inp = rio('d/f2')
-    out = rio(?")
+    inp = rio(DNAME_F,FNAMES_F[0])
+    out = rio(OUTDIR,"file_out.txt")
     rtn = inp | out
     exp = inp[]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
   end
 
   def test_file_cmd_out
-    inp = rio('d/f2')
-    cmd = rio(?-,PROG['find_lines']+' 1')
-    out = rio(?")
+    inp = rio(DNAME_F,FNAMES_F[0])
+    cmd = rio(?-,PROG[:find_lines]+' 1')
+    out = rio(OUTDIR,"file_cmd_out.txt")
     rtn = inp | cmd | out
     exp = inp[/1/]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
   end
 
   def test_file_cmd_cmd_out
-    inp = rio('d/f2')
-    cmd = rio(?-,PROG['find_lines']+' 1')
-    cmd2 = rio(?-,PROG['find_lines']+' 0')
-    out = rio(?")
+    inp = rio(DNAME_F,FNAMES_F[0])
+    cmd = rio(?-,PROG[:find_lines]+' 1')
+    cmd2 = rio(?-,PROG[:find_lines]+' 0')
+    out = rio(OUTDIR,"file_cmd_cmd_out.txt")
     rtn = inp | cmd | cmd2 | out
     exp = inp[/10/]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
   end
 
   def test_file_cmdpipe_out2
-    inp = rio('d/f2')
-    cmd = rio(?-,PROG['find_lines']+' 1')
-    cmd2 = rio(?-,PROG['find_lines']+' 0')
+    inp = rio(DNAME_F,FNAMES_F[0])
+    cmd = rio(?-,PROG[:find_lines]+' 1')
+    cmd2 = rio(?-,PROG[:find_lines]+' 0')
 
     cmdpipe = inp | cmd | cmd2
     assert_equal('cmdpipe',cmdpipe.scheme)
 
-    out = rio(?")
+    out = rio(OUTDIR,"file_cmdpipe_out2.txt")
     rtn = cmdpipe | out
     exp = inp[/10/]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
 
-    out = rio(?")
+    out = rio(OUTDIR,"file_cmdpipe_out2.txt")
     rtn = cmdpipe | out
     exp = inp[/10/]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
   end
 
-  def test_file_cmdpipe_out
-    inp = rio('d/f2')
-    cmd = rio(?-,PROG['find_lines']+' 1')
-    cmd2 = rio(?-,PROG['find_lines']+' 0')
-    out = rio(?")
 
-    cmdpipe = cmd | cmd2
-    assert_equal('cmdpipe',cmdpipe.scheme)
 
-    rtn = inp | cmdpipe | out
-    exp = inp[/10/]
-    assert_equal(exp,out[])
-    assert_equal(rtn,out)
+  def test_file_obj_out
+    RIO::DBG::trace_states(false) do
+      inp = rio(DNAME_F,FNAMES_F[0])
+      cmd = rio(?-,PROG[:find_lines]+' 1')
+      cmd2 = rio(?-,PROG[:find_lines]+' 0')
+      out = rio(OUTDIR,"file_obj_out.txt")
+      
+      obj = cmd | cmd2
+      # p "test_file_obj_out: #{obj.inspect}"
+      assert_equal('cmdpipe',obj.scheme)
+      
+      rtn = inp | obj | out
+      exp = inp[/10/]
+      assert_equal(exp,out[])
+      assert_equal(out,rtn)
+    end
   end
 
   def test_cmdpipe_without
-    cmd = rio(?-,PROG['find_lines']+' 1')
-    cmd2 = rio(?-,PROG['find_lines']+' 0')
+    #$trace_states = true
+    cmd = rio(?-,PROG[:find_lines]+' 1')
+    cmd2 = rio(?-,PROG[:find_lines]+' 0')
     out = rio(?")
 
     cmdpipe = rio(?|,cmd,cmd2,out)
     assert_equal('cmdpipe',cmdpipe.scheme)
 
-    inp = rio('d/f2')
-    rtn = inp | cmdpipe
-    exp = inp[/10/]
-    assert_equal(exp,out[])
-    assert_equal(rtn,out)
-
-    inp = rio('d/f1')
+    inp = rio(DNAME_F,FNAMES_F[0])
     rtn = inp | cmdpipe
     exp = inp[[/1/,/0/]]
     assert_equal(exp,out[])
-    assert_equal(rtn,out)
+    assert_equal(out,rtn)
 
   end
 
+
+  def test_in_cmd_out
+    input = rio(:-,'ls',DNAME_G)
+    output = rio(OUTDIR,'in_cmd_out.txt')
+    cat = rio(:-,'cat','-n')
+    input | cat | output
+    assert_match(/\s+1\s+g1/,output.chomp.line[0])
+    assert_match(/\s+2\s+g2/,output.chomp.line[1])
+  end
+
+  def test_in_out
+    input = rio(:-,'ls')
+    output = rio(OUTDIR,'in_out.txt')
+    input | output
+    assert_equal([DNAME_F,DNAME_G,OUTDIR], output.chomp[])
+  end
+
+  def test_cmd_cmd_obj
+    input = rio(:-,'ls')
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+    obj = cat1 | cat2
+    assert_equal('cmdpipe',obj.scheme)
+    assert_equal(cat1,obj.rl.query[0])
+    assert_equal(cat2,obj.rl.query[1])
+  end
+
+  def test_file_cmd_cmd_file2
+    input = rio(DNAME_F,FNAMES_F[0])
+    output = rio(OUTDIR,'file_obj_file.txt')
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+    obj = cat1 | cat2
+    input | obj.rl.query[0] | obj.rl.query[1] | output
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+      assert_match(/\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+  def test_file_obj_file
+    input = rio(DNAME_F,FNAMES_F[0])
+    output = rio(OUTDIR,'file_obj_file.txt')
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+    obj = cat1 | cat2
+    input | obj | output
+    n_lines = 3 #N_LINES
+    #p output[]
+    (1..n_lines).each do |n|
+      assert_match(/\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+  def test_file_obj_file3
+    input = rio(DNAME_F,FNAMES_F[0])
+    str = ""
+    strio = StringIO.new(str)
+    output = rio(strio)
+    cat1 = rio(:-,'cat','-n')
+
+    obj = input | cat1
+    obj | output
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+      assert_match(/^\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+  def test_file_cmd_cmd_file
+    input = rio(DNAME_F,FNAMES_F[0])
+    output = rio(OUTDIR,'file_obj_file.txt')
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+    input | cat1 | cat2 | output
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+
+      assert_match(/^\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+  def test_file_obj_file2
+    input = rio(DNAME_F,FNAMES_F[0])
+    str = ""
+    strio = StringIO.new(str)
+    output = rio(strio)
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+
+    obj = cat1 | cat2
+    input | obj | output
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+      assert_match(/^\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+  def test_file_obj_file4
+    input = rio(DNAME_F,FNAMES_F[0])
+    str = ""
+    strio = StringIO.new(str)
+    output = rio(strio)
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+
+    obj = input | cat1 | cat2
+    obj | output
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+      assert_match(/^\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+  def test_file_obj_file5
+    input = rio(DNAME_F,FNAMES_F[0])
+    str = ""
+    strio = StringIO.new(str)
+    output = rio(strio)
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+
+    obj1 = cat1 | cat2
+    obj2 = input | obj1
+    obj2 | output
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+      assert_match(/^\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+
+  def test_file_obj_file6
+    input = rio(DNAME_F,FNAMES_F[0])
+    str = ""
+    strio = StringIO.new(str)
+    output = rio(strio)
+    cat1 = rio(:-,'cat','-n')
+    cat2 = rio(:-,'cat','-n')
+    cat3 = rio(:-,'cat','-n')
+
+    obj1 = cat1 | cat2
+    obj2 = obj1 | cat3
+
+    input | obj2 | output
+
+    n_lines = 3 #N_LINES
+    (1..n_lines).each do |n|
+      assert_match(/^\s+#{n}\s+#{n}\s+#{n}\s+Line #{n}/,output.line[n-1])
+    end
+
+  end
+
+
+
+
+
 end