wishdev-rio 0.4.3.1

data/test/tc/testcase.rb

@@ -0,0 +1,170 @@
+require 'rio'
+require 'test/unit'
+require 'test/unit/testsuite'
+
+
+
+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
+$mswin32 = (RUBY_PLATFORM =~ /mswin32/)
+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 { |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 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
+      include RIO_TestCase::Util
+      def setup()
+        return if self.class == Test::RIO::TestCase
+        #p self.class
+        @cwd = ::Dir.getwd
+        tdir.mkpath.chdir
+      end
+      def teardown
+        return if self.class == Test::RIO::TestCase
+        ::Dir.chdir @cwd
+      end
+      def rios2str(a) a.map { |el| el.to_s } end
+
+      def assert!(a,msg="negative assertion")
+        assert((!(a)),msg)
+      end
+
+      def smap(a) a.map { |el| el.to_s } end
+      def assert_array_equal(a,b,msg="array same regardless of order")
+        if a.nil?
+          assert_nil(b)
+        elsif b.nil?
+          assert_nil(a)
+        else
+          assert_equal(smap(a).sort,smap(b).sort,msg)
+        end
+      end
+      def assert_dirs_equal(exp,d,msg="")
+        exp.each do |ent|
+          ds = rio(d,ent.filename)
+          assert_equal(ent.symlink?,ds.symlink?,"both symlinks, or not")
+          unless ent.symlink?
+            assert(ds.exist?,"entry '#{ds}' exists")
+          end
+          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.symlink?
+          assert(ans.symlink?,"entry is a symlink")
+          assert_equal(exp.readlink,ans.readlink,"symlinks read the same")
+        when exp.file?
+          assert(ans.file?,"entry is a file")
+          assert_equal(exp.chomp.lines[],ans.chomp.lines[],"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 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

data/test/tc/tonl.rb

@@ -0,0 +1,37 @@
+#!/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_tonl < Test::RIO::TestCase
+  @@once = false
+  CRNLFILE = 'hw.crnl.txt'
+  NLFILE = 'hw.nl.txt'
+  STR = "Hello World\r\n"
+  require 'tc/programs_util'
+  include Test::RIO::Programs
+
+  def self.once
+    @@once = true
+    rio(CRNLFILE) <  STR * 2
+ end
+  def setup
+    super
+    self.class.once unless @@once
+  end
+
+  def test_1
+    out = rio.strio
+    rio(CRNLFILE) > out
+    lines = rio(CRNLFILE).to_a
+    assert_equal(13,lines[0].length)
+    rio(NLFILE) < rio(CRNLFILE).chomp.map{ |l| "#{l}\n" }
+    lines = rio(NLFILE).to_a
+    assert_equal(12,lines[0].length)
+  end
+
+end

data/test/tc/truncate.rb

@@ -0,0 +1,39 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+require 'rio'
+require 'tc/testcase'
+require 'pp'
+
+class TC_truncate < Test::RIO::TestCase
+  @@once = false
+  def self.once
+    @@once = true
+
+  end
+
+  def setup
+    super
+    self.class.once unless @@once
+
+  end
+
+  def test_basic
+    str = "1234567890"
+    f = rio("out")
+    f.print!(str)
+    assert_equal(str,f.contents)
+    assert_equal(str.size,f.size)
+    n = 5
+    f.truncate(n)
+    assert_equal(str[0,n],f.contents)
+    assert_equal(n,f.size)
+    n = 2
+    assert_equal(str[0,n],f.read(n))
+    assert_equal(n,f.truncate.size)
+    assert_equal(str[0,n],f.contents)
+  end
+
+end

data/test/tc/yaml.rb

@@ -0,0 +1,275 @@
+#!/usr/local/bin/ruby
+if $0 == __FILE__
+  Dir.chdir File.dirname(__FILE__)+'/../'
+  $:.unshift File.expand_path('../lib/')
+end
+
+require 'rio'
+require 'tc/testcase'
+require 'tc/csvutil'
+
+class TC_yaml < Test::RIO::TestCase
+  include CSV_Util
+
+  @@once = false
+  TRIO = rio('test.yaml')
+  TOBJS = [
+    ['zero','one','two'],
+    {'zero' => 0, 'one' => 1, 'two' => 2},
+    "the crux of the biscuit",
+  ]
+  def self.once
+    @@once = true
+    tdir.delete!.mkpath.chdir {
+      TRIO.puts!(YAML.dump_stream(*TOBJS))
+    }
+  end
+  def setup()
+    self.class.once unless @@once
+    super
+  end
+
+  def test_ss
+    0.upto(2) do |n|
+      exp = [TOBJS[n]]
+      ans = rio(TRIO).yaml[n]
+      assert_equal(exp,ans)
+      ans = rio(TRIO).yaml[TOBJS[n].class]
+      assert_equal(exp,ans)
+    end
+  end
+  def test_copyop
+    objs = rio(TRIO).yaml[]
+    assert_equal(TOBJS,objs)
+    ofile = 'out.yml'
+    yout = rio(ofile).yaml.delete << objs[0] << objs[1] << objs[2]
+    assert_equal(rio(TRIO)[],rio(ofile)[])
+    rio(?",ostring = "").yaml < yout
+    assert_equal(rio(TRIO).contents,ostring)
+  end
+  def test_yaml2csv
+    data = [["h0","h1","h2"],["d0","d1","d2"]]
+    csvfile = 'y2c.csv'
+    ymlfile = 'y2c.yml'
+    dat = data.map{|d| d.join(',')}
+    rio(csvfile).puts!(dat)
+    val = rio(csvfile).contents
+    assert_equal(dat.join($/)+$/,val)
+    rio(ymlfile).yaml < rio(csvfile).csv
+    ans = rio(ymlfile).yaml[]
+    assert_equal(data,ans)
+    #puts rio(ymlfile).contents
+  end
+  def test_select
+    ans = rio(TRIO).yaml.records[]
+    assert_equal(TOBJS,ans)
+    ans = rio(TRIO).yaml.objects[]
+    assert_equal(TOBJS,ans)
+
+    ans = rio(TRIO).yaml.rows[]
+    assert_equal(TOBJS,ans.map{|obj| ::YAML.load(obj)})
+    ans = rio(TRIO).yaml.documents[]
+    assert_equal(TOBJS,ans.map{|obj| ::YAML.load(obj)})
+
+    exp = [TOBJS[1]]
+    ans = rio(TRIO).yaml.records[1]
+    assert_equal(exp,ans)
+    ans = rio(TRIO).yaml.objects[1]
+    assert_equal(exp,ans)
+
+    ans = rio(TRIO).yaml.rows[1]
+    assert_equal(exp,ans.map{|obj| ::YAML.load(obj)})
+    ans = rio(TRIO).yaml.documents[1]
+    assert_equal(exp,ans.map{|obj| ::YAML.load(obj)})
+
+    exp = [TOBJS[0],TOBJS[2]]
+    ans = rio(TRIO).yaml.skiprecords[1]
+    assert_equal(exp,ans)
+    ans = rio(TRIO).yaml.skipobjects[1]
+    assert_equal(exp,ans)
+
+    ans = rio(TRIO).yaml.skiprows[1]
+    assert_equal(exp,ans.map{|obj| ::YAML.load(obj)})
+    ans = rio(TRIO).yaml.skipdocuments[1]
+    assert_equal(exp,ans.map{|obj| ::YAML.load(obj)})
+
+    exp = [TOBJS[1]]
+    ans = rio(TRIO).yaml.records[::Hash]
+    assert_equal(exp,ans)
+    ans = rio(TRIO).yaml.objects[::Hash]
+    assert_equal(exp,ans)
+
+    exp = [TOBJS[0],TOBJS[2]]
+    ans = rio(TRIO).yaml.skiprecords[::Hash]
+    assert_equal(exp,ans)
+    ans = rio(TRIO).yaml.skipobjects[::Hash]
+    assert_equal(exp,ans)
+
+  end
+  def test_single
+    exp = TOBJS[1]
+    ans = rio(TRIO).yaml.record[1]
+    assert_equal(exp,ans)
+    ans = rio(TRIO).yaml.row[1]
+    assert_equal(exp,::YAML.load(ans))
+    ans = rio(TRIO).yaml.object[1]
+    assert_equal(exp,ans)
+    ans = rio(TRIO).yaml.document[1]
+    assert_equal(exp,::YAML.load(ans))
+  end
+  def test_copytypes
+    ofile = 'out.yml'
+    [1,"1",{'one'=>1},[1]].each do |obj|
+      rio(ofile).yaml < obj
+      assert_equal(obj,rio(ofile).yaml.load)
+    end
+  end
+  def test_copytoary
+    ofile = 'out.yml'
+    in_ary = [1,"1",{'one'=>1},[1]]
+    ary = []
+    in_ary.each do |obj|
+      rio(ofile).yaml < obj
+      assert_equal(obj,rio(ofile).yaml.load)
+      rio(ofile).yaml >> ary
+    end
+    assert_equal(in_ary,ary)
+  end
+  def test_get
+    exp = TOBJS[0]
+
+    obj = rio(TRIO).yaml.get
+    assert_instance_of(exp.class,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.records.get
+    assert_instance_of(exp.class,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.lines.get
+    assert_instance_of(::String,obj)
+    assert_equal(rio(TRIO).lines[0],[obj])
+
+    exp = ::YAML.dump(exp)
+    obj = rio(TRIO).yaml.rows.get
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+  end
+  def test_each
+    exp = TOBJS
+
+    ans = []
+    rio(TRIO).yaml do |obj|
+      ans << obj
+    end
+    (0...exp.size).each do |i|
+      assert_equal(exp[i],ans[i])
+    end
+
+    ans = []
+    rio(TRIO).yaml.records do |obj|
+      ans << obj
+    end
+    (0...exp.size).each do |i|
+      assert_equal(exp[i],ans[i])
+    end
+
+    ans = []
+    rio(TRIO).yaml.rows do |obj|
+      ans << ::YAML.load(obj)
+    end
+    (0...exp.size).each do |i|
+      assert_equal(exp[i],ans[i])
+    end
+
+    exp = rio(TRIO).lines[]
+    ans = []
+    rio(TRIO).yaml.lines do |obj|
+      ans << obj
+    end
+    (0...exp.size).each do |i|
+      assert_equal(exp[i],ans[i])
+    end
+
+  end
+  def test_array
+    exp = TOBJS
+
+    ans = rio(TRIO).yaml[]
+    assert_equal(exp,ans)
+
+    ans = rio(TRIO).yaml.records[]
+    assert_equal(exp,ans)
+
+    ans = rio(TRIO).yaml.rows[]
+    assert_equal(exp,ans.map{|obj| ::YAML.load(obj)})
+
+    exp = rio(TRIO).lines[]
+    ans = rio(TRIO).yaml.lines[]
+    assert_equal(exp,ans)
+
+  end
+  def test_getrec
+    exp = TOBJS[0]
+
+    obj = rio(TRIO).yaml.getrec
+    assert_instance_of(::Array,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.lines.getrec
+    assert_instance_of(::Array,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.records.getrec
+    assert_instance_of(::Array,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.rows.getrec
+    assert_instance_of(::Array,obj)
+    assert_equal(exp,obj)
+
+  end
+  def test_getrow
+    exp = TOBJS[0].to_yaml
+
+    obj = rio(TRIO).yaml.getrow
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.lines.getrow
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.records.getrow
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.rows.getrow
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+  end
+  def test_getline
+    exp = rio(TRIO).gets
+
+    obj = rio(TRIO).yaml.getline
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.lines.getline
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.records.getline
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+    obj = rio(TRIO).yaml.rows.getline
+    assert_instance_of(::String,obj)
+    assert_equal(exp,obj)
+
+  end
+
+
+end