sixarm_ruby_ramp 2.1.3 → 3.0.0

data/test/sixarm_ruby_ramp_test/file_test.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+
+class FileTestCase < Minitest::Test
+
+  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/sixarm_ruby_ramp_test/fixnum_test.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+
+class FixnumTest < Minitest::Test
+
+  def test_even_with_true
+    assert(2.even?)
+  end
+
+  def test_even_with_false
+    assert(!3.even?)
+  end
+
+  def test_odd_with_true
+    assert(3.odd?)
+  end
+
+  def test_odd_with_false
+    assert(!2.odd?)
+  end
+
+end
+

data/test/sixarm_ruby_ramp_test/hash_test.rb

@@ -0,0 +1,209 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+class HashTest < Minitest::Test
+
+
+  def test_size_true
+    h = {'a'=>'b'}
+    assert(h.size?)
+  end
+
+
+  def test_size_false
+    h = {}
+    assert(!h.size?)
+  end
+
+
+  def test_sort_by_keys
+    h = {'c' => 'z', 'b' => 'y', 'a' => 'x'}
+    assert_equal({'a' => 'x', 'b' => 'y', 'c' => 'z'}, h.sort_by_keys)
+  end
+
+
+  def test_each_sort
+    out = []
+    h = {'c' => 'z', 'b' => 'y', 'a' => 'x'}
+    h.each_sort{|key,val| out << key.upcase; out << val.upcase}
+    assert_equal(['A','X','B','Y','C','Z'], out)
+  end
+
+
+  def test_each_sort_with_empty
+    out = []
+    h = {}
+    h.each_sort{|key,val| out << key.upcase; out << val.upcase}
+    assert_equal([], out)
+  end
+
+
+  def test_each_key_bang
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "A" => "b", "C" => "d" }
+    actual.each_key! {|key| key.upcase }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_key_bang_with_empty
+    actual = {}
+    expect = {}
+    actual.each_key! {|key| key.upcase }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_pair_bang
+    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_pair_bang_with_empty
+    actual = {}
+    expect = {}
+    actual.each_pair! {|key,value| [key.upcase, value.upcase] }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_pair_bang_with_same_key_different_value
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "a" => "B", "c" => "D" }
+    actual.each_pair! {|key,value| [key, value.upcase] }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_pair_bang_with_same_key_same_value
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "a" => "b", "c" => "d" }
+    actual.each_pair! {|key,value| [key, value] }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_value_bang
+    actual = { "a" => "b", "c" => "d" }
+    expect = { "a" => "B", "c" => "D" }
+    actual.each_value! {|value| value.upcase }
+    assert_equal(expect,actual)
+  end
+
+
+  def test_each_value_bang_with_empty
+    actual = {}
+    expect = {}
+    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 test_map_pair_with_empty
+    h = {}
+    expect=[]
+    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.join }
+    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.join }
+    assert_equal(['a','b','c'], p.keys.sort)
+    assert_equal('mno', p['a'])
+    assert_equal('pqr', p['b'])
+    assert_equal('stu', p['c'])
+  end
+
+
+  def test_pivot_direction_up_with_true
+    Hash.publicize_methods do
+      assert({}.pivot_direction_up?('key'))
+      assert({}.pivot_direction_up?('keys'))
+      assert({}.pivot_direction_up?('up'))
+      assert({}.pivot_direction_up?('left'))
+      assert({}.pivot_direction_up?('out'))
+    end
+  end
+
+
+  def test_pivot_direction_up_with_false
+    Hash.publicize_methods do
+      assert(!{}.pivot_direction_up?('val'))
+      assert(!{}.pivot_direction_up?('vals'))
+      assert(!{}.pivot_direction_up?('down'))
+      assert(!{}.pivot_direction_up?('right'))
+      assert(!{}.pivot_direction_up?('in'))
+    end
+  end
+
+
+  def test_pivot_direction_up_with_invalid
+    Hash.publicize_methods do
+      assert_raises(ArgumentError){ {}.pivot_direction_up?('nonsense') }
+    end
+  end
+
+
+end
+
+
+
+

data/test/sixarm_ruby_ramp_test/integer_test.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+
+class IntegerTest < Minitest::Test
+
+  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/sixarm_ruby_ramp_test/io_test.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+class IOTest < Minitest::Test
+
+ def test_load_dir_files
+   dirpath=File.join(__dir__,'io_test*')
+   expect=[File.join(__dir__,'io_test.rb'),File.join(__dir__,'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(__dir__,'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(__dir__,'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/sixarm_ruby_ramp_test/kernel_test.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+class KernelTest < Minitest::Test
+
+  class TestMyMethodName
+    def a
+      my_method_name  
+    end
+  end
+
+  class TestCallerMethodNameWithNoOps
+    def a
+      caller_method_name()
+    end
+  end
+
+  class TestCallerMethodNameWithIndex0
+    def a
+      caller_method_name(0)  
+    end
+  end
+
+  class TestCallerMethodNameWithIndex1
+    def a
+      b
+    end
+    def b
+      caller_method_name(1) 
+    end
+  end
+
+  def test_my_method_name
+    assert_equal('a', TestMyMethodName.new.a)
+  end
+
+  def test_caller_method_name_with_no_ops
+    assert_equal('a', TestCallerMethodNameWithNoOps.new.a)
+  end
+
+  def test_caller_method_name_with_index_0
+    assert_equal('a', TestCallerMethodNameWithIndex0.new.a)
+  end
+
+  def test_caller_method_name_with_index_1
+    assert_equal('a', TestCallerMethodNameWithIndex1.new.a)
+  end
+
+  def test_pp_s
+    assert_equal(":foo\n",pp_s(:foo))
+  end
+
+end
+

data/test/sixarm_ruby_ramp_test/math_test.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+class MathTest < Minitest::Test
+
+  def test_ln
+    assert_equal(0.0,Math.ln(1.0))
+    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/sixarm_ruby_ramp_test/nil_test.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+class NilTest < Minitest::Test
+
+ def test_blank
+  assert_equal(true,nil.blank?)
+ end
+
+ def test_size
+  assert_equal(false,nil.size?)
+ end
+
+end
+

data/test/sixarm_ruby_ramp_test/numeric_test.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+class NumericTest < Minitest::Test
+
+
+  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
+
+
+  def test_percent_with_ndigits_default
+    assert_equal(12, (0.1234).percent)
+  end
+
+
+  def test_percent_with_ndigits_zero
+    assert_equal(12, (0.1234).percent(0))
+  end
+
+
+  def test_percent_with_ndigits_positive
+    assert_equal(12.3, (0.1234).percent(1))
+  end
+
+
+  def test_percent_with_ndigits_negative
+    assert_equal(10, (0.1234).percent(-1))
+  end
+
+
+  def test_floor_precision
+    x = 0.12345
+    assert_equal(0.0, x.floor_precision(0))
+    assert_equal(0.1, x.floor_precision(1))
+    assert_equal(0.12, x.floor_precision(2))
+    assert_equal(0.123, x.floor_precision(3))
+  end
+
+
+end