webget_ruby_ramp 1.7.2

data/test/webget_ruby_ramp/file_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class FileTestCase < Test::Unit::TestCase
+
+  def test_load_dir_files
+    filename='/a/b/c.d'
+    dirname=File.dirname(filename)
+    expect=File.join(dirname,'x','y','z')   
+    actual=File.joindir(filename,'x','y','z')
+    assert_equal(expect,actual,"filename:#{filename} dirname:#{dirname}")
+  end
+
+end
+

data/test/webget_ruby_ramp/hash_test.rb

@@ -0,0 +1,105 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class HashTest < Test::Unit::TestCase
+
+
+  def test_size
+    h = {'a'=>'b'}
+    assert(h.size?)
+    h = {}
+    assert(!h.size?)
+  end
+
+
+  def test_each_key
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "A" => "b", "C" => "d" }
+    actual.each_key! {|key| key.upcase }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_pair
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "A" => "B", "C" => "D" }
+    actual.each_pair! {|key,value| [key.upcase, value.upcase] }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_value
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "a" => "B", "c" => "D" }
+    actual.each_value! {|value| value.upcase }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_map_pair
+    h = {"a"=>"b", "c"=>"d", "e"=>"f" }
+    expect=["ab","cd","ef"]  
+    actual=h.map_pair{|key,value| key+value }.sort
+    assert_equal(expect,actual,h.inspect)
+  end
+   
+
+  def pivotable
+    h=Hash.new
+    h['a']=Hash.new
+    h['b']=Hash.new
+    h['c']=Hash.new
+    h['a']['x']='m'
+    h['a']['y']='n'
+    h['a']['z']='o'
+    h['b']['x']='p'
+    h['b']['y']='q'
+    h['b']['z']='r'
+    h['c']['x']='s'
+    h['c']['y']='t'
+    h['c']['z']='u'
+    return h
+  end  
+
+
+  def test_pivot_vals
+    p=pivotable.pivot(:vals)
+    assert_equal(['x','y','z'], p.keys.sort)
+    assert_equal(['m','p','s'], p['x'].sort)
+    assert_equal(['n','q','t'], p['y'].sort)
+    assert_equal(['o','r','u'], p['z'].sort)
+  end
+
+
+  def test_pivot_vals_with_block
+    p=pivotable.pivot(:vals){|items| items.sort.inject{|sum,x| sum+=x}}
+    assert_equal(['x','y','z'], p.keys.sort)
+    assert_equal('mps', p['x'])
+    assert_equal('nqt', p['y'])
+    assert_equal('oru', p['z'])
+  end
+
+
+  def test_pivot_keys
+    p=pivotable.pivot(:keys)
+    assert_equal(['a','b','c'], p.keys.sort)
+    assert_equal(['m','n','o'], p['a'].sort)
+    assert_equal(['p','q','r'], p['b'].sort)
+    assert_equal(['s','t','u'], p['c'].sort)
+  end
+
+
+  def test_pivot_keys_with_block
+    p=pivotable.pivot(:keys){|items| items.sort.inject{|sum,x| sum+=x}}
+    assert_equal(['a','b','c'], p.keys.sort)
+    assert_equal('mno', p['a'])
+    assert_equal('pqr', p['b'])
+    assert_equal('stu', p['c'])
+  end
+
+
+end
+
+
+
+

data/test/webget_ruby_ramp/integer_test.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class IntegerTest < Test::Unit::TestCase
+
+  def test_maps
+    expect=['a','a','a']
+    actual=3.maps{'a'}
+    assert_equal(expect,actual)
+  end
+
+  def test_maps_with_index
+    expect=[0,1,2]
+    actual=3.maps{|i| i}
+    assert_equal(expect,actual)
+  end
+
+end
+

data/test/webget_ruby_ramp/io_test.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class IOTest < Test::Unit::TestCase
+
+ MYDIR=File.join('test','webget_ruby_ramp')
+
+ def test_load_dir_files
+   dirpath=File.join(MYDIR,'io_test*')
+   expect=[File.join(MYDIR,'io_test.rb'),File.join(MYDIR,'io_test.txt')]
+   actual=Dir[dirpath].sort
+   assert_equal(expect,actual,"Dir[#{dirpath}] expects test data files")
+ end
+
+ def test_readrow
+   filename=Dir[File.join(MYDIR,'io_test.txt')].first
+   f=File.open(filename)
+   assert_equal(["A1","B1","C1"],f.readrow(:row=>"=",:col=>"-"))
+   assert_equal(["A2","B2","C2"],f.readrow(:row=>"=",:col=>"-"))
+   assert_equal(["A3","B3","C3"],f.readrow(:row=>"=",:col=>"-"))
+ end
+
+ def test_readrows
+   filename=Dir[File.join(MYDIR,'io_test.txt')].first
+   expect=[["A1","B1","C1"],["A2","B2","C2"],["A3","B3","C3"]]
+   actual=IO.readrows(filename,:row=>"=",:col=>"-")
+   assert_equal(expect,actual)
+ end
+
+end
+

data/test/webget_ruby_ramp/io_test.txt

@@ -0,0 +1 @@
+A1-B1-C1=A2-B2-C2=A3-B3-C3

data/test/webget_ruby_ramp/kernel_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class KernelTest < Test::Unit::TestCase
+
+ def test_method_name
+  assert_equal('test_method_name',method_name)
+ end
+
+ def test_pp_s
+  assert_equal(":foo\n",pp_s(:foo))
+ end
+
+end
+

data/test/webget_ruby_ramp/math_test.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class MathTest < Test::Unit::TestCase
+
+  def test_ln
+    assert_equal(1.0,Math.ln(Math.exp(1.0)))
+  end
+
+  def test_logn
+    assert_equal(1.0,Math.logn(3,3),'log of 3 base 3')
+    assert_equal(2.0,Math.logn(9,3),'log of 9 base 3')
+    assert_equal(3.0,Math.logn(27,3),'log of 27 base 3')
+  end
+
+end
+

data/test/webget_ruby_ramp/nil_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class NilTest < Test::Unit::TestCase
+
+ def test_blank
+  assert_equal(true,nil.blank?)
+ end
+
+ def test_size
+  assert_equal(false,nil.size?)
+ end
+
+end
+

data/test/webget_ruby_ramp/numeric_test.rb

@@ -0,0 +1,28 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class NumericTest < Test::Unit::TestCase
+
+
+  def test_if_with_true
+    assert_equal(5,5.if(true))
+  end
+
+
+  def test_if_with_false
+    assert_equal(0,5.if(false))
+  end
+
+
+  def test_unless_with_true
+    assert_equal(0,5.unless(true))
+  end
+
+
+  def test_unless_with_false
+    assert_equal(5,5.unless(false))
+  end
+
+
+end
+

data/test/webget_ruby_ramp/object_test.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class ObjectTest < Test::Unit::TestCase
+
+ def test_in_array
+  assert_equal(true,'a'.in?(['a','b','c']))
+  assert_equal(false,'x'.in?(['a','b','c']))
+ end
+
+end
+

data/test/webget_ruby_ramp/process_test.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+class ProcessTest < Test::Unit::TestCase
+
+ include Process
+
+ def test_ps
+  p=Process.ps
+  assert(p!=nil,"ps != nil")
+  assert(p.is_a?(String),"ps is a string")
+  assert(p.size>0,"ps size > 0")
+ end
+
+ def test_pss
+  p=Process.pss
+  assert(p!=nil,"pss != nil")
+  assert(p.is_a?(Hash),"ps_hash is a hash")
+  assert(p.size>0,"pss size > 0")
+  assert(p['pcpu']!=nil,"ps_hash pcpu != nil")
+ end
+  
+end
+

data/test/webget_ruby_ramp/string_test.rb

@@ -0,0 +1,125 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+
+class StringTest < Test::Unit::TestCase
+
+
+  def test_capitalize_words
+    assert_equal("Foo Goo Hoo","foo goo hoo".capitalize_words)
+  end
+
+
+  def test_words
+    assert_equal(['foo','goo','hoo'],"foo goo hoo".words)
+  end
+
+
+  def test_split_tab
+    assert_equal(['foo','goo','hoo'],"foo\tgoo\thoo".split_tab)
+  end
+
+
+  def test_split_tsv
+    assert_equal([['a','b','c'],['d','e','f'],['g','h','i']],"a\tb\tc\nd\te\tf\ng\th\ti".split_tsv)
+  end
+
+
+  def test_lowcase
+    assert_equal('foo_goo_hoo',"Foo GOO**_**Hoo".lowcase)
+  end
+
+  
+  def test_to_class
+    assert_equal(String,'String'.to_class)
+  end
+
+
+  def test_to_class_nested
+    assert_equal(FooModule::FooClass,'FooModule::FooClass'.to_class)
+  end
+
+
+  def test_increment
+    assert_equal('5','4'.increment,               'number is entire string')
+    assert_equal('5foo','4foo'.increment,         'number is leftmost')
+    assert_equal('foo5','foo4'.increment,         'number is rightmost')
+    assert_equal('foo10','foo9'.increment,        'number is rightmost with carry')
+    assert_equal('foo5bar','foo4bar'.increment,   'number is in then middle')
+    assert_equal('foobar','foobar'.increment,     'no number, so should be unchanged')
+  end
+
+
+  def test_decrement
+    assert_equal('3','4'.decrement,               'number is entire string')
+    assert_equal('3foo','4foo'.decrement,         'number is leftmost')
+    assert_equal('foo3','foo4'.decrement,         'number is rightmost')
+    assert_equal('foo9','foo10'.decrement,        'number is rightmost with carry')
+    assert_equal('foo3bar','foo4bar'.decrement,   'number is in then middle')
+    assert_equal('foobar','foobar'.decrement,     'no number, so should be unchanged')
+  end
+
+
+  def test_prev_char
+    assert_equal(["-",false,false] ,String.prev_char("-"))  #unchanged
+    assert_equal(["5",true,false]  ,String.prev_char("6"))  #numeric typical
+    assert_equal(["9",true,true]   ,String.prev_char("0"))  #numeric carry
+    assert_equal(["m",true,false]  ,String.prev_char("n"))  #lowercase typical
+    assert_equal(["z",true,true]   ,String.prev_char("a"))  #lowercase carry
+    assert_equal(["M",true,false]  ,String.prev_char("N"))  #uppercase typical
+    assert_equal(["Z",true,true]   ,String.prev_char("A"))  #uppercase carry
+  end
+
+
+  def test_prev
+    assert_equal('n-','n-'.prev)     # unchanged
+    assert_equal('n5','n6'.prev)     # numeric typical
+    assert_equal('m9','n0'.prev)     # numeric carry
+    assert_equal('m999','n000'.prev) # numeric carries
+    assert_equal('ne','nf'.prev)     # lowercase typical
+    assert_equal('mz','na'.prev)     # lowercase carry
+    assert_equal('mzzz','naaa'.prev) # lowercase carries
+    assert_equal('NE','NF'.prev)     # uppercase typical
+    assert_equal('MZ','NA'.prev)     # uppercase carry
+    assert_equal('MZZZ','NAAA'.prev) # uppercase carries
+  end
+
+  def test_lorem_length
+    x = String.lorem_length
+    assert(x.is_a?(Integer),'x is integer')
+    assert(x>0,"x:#{x}>0")
+    assert(x<=20,"x:#{x}<=20")
+  end
+
+  def test_lorem
+    s = String.lorem
+    assert(s.is_a?(String),'s is string')
+    assert(s.size>0,"s.size:#{s.size}>0")
+    assert(s.size<20,"s.size:#{s.size}<=20")
+  end
+
+  def test_lorem_with_length
+    s = String.lorem(5)
+    assert(s.is_a?(String),'s is string')
+    assert(s.size==5,"s.size:#{s.size}==5")
+  end
+
+end
+
+
+# For testing #to_class
+module FooModule #:nodoc: all
+  class FooClass
+  end
+end
+
+
+
+
+
+
+
+
+
+
+

data/test/webget_ruby_ramp/symbol_test.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'webget_ruby_ramp'
+
+
+class SymbolTest < Test::Unit::TestCase
+
+
+  def test_comparable
+    assert_equal(-1,:foo<=>:goo)
+    assert_equal( 0,:foo<=>:foo)
+    assert_equal( 1,:goo<=>:foo)
+  end
+
+
+end
+
+
+
+
+
+
+
+
+
+
+