sixarm_ruby_ramp 2.1.3 → 3.0.0

data/test/sixarm_ruby_ramp_test/class_test.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+
+class ClassTest < Minitest::Test
+
+  
+  METHOD_REGEXP = /^[abc]\W*$/
+  def test_publicize_methods
+
+    # Before we test the block, ensure our setup is correct
+    assert_equal(["a","a!","a=","a?"],My.private_instance_methods.grep_sort_to_s(METHOD_REGEXP),'private methods before block')
+    assert_equal(["b","b!","b=","b?"],My.protected_instance_methods.grep_sort_to_s(METHOD_REGEXP),'protected methods before block')
+    assert_equal(["c","c!","c=","c?"],My.public_instance_methods.grep_sort_to_s(METHOD_REGEXP),'public methods before block')
+
+    # Now we test inside the block
+    My.publicize_methods{
+      assert_equal([],My.private_instance_methods.grep_sort_to_s(METHOD_REGEXP),'private methods inside block')
+      assert_equal([],My.protected_instance_methods.grep_sort_to_s(METHOD_REGEXP),'protected methods inside block')
+      assert_equal(["a","a!","a=","a?","b","b!","b=","b?","c","c!","c=","c?"],My.public_instance_methods.grep_sort_to_s(METHOD_REGEXP),'public methods inside block')
+    }
+
+    # After we test the block, ensure our setup is restored
+    assert_equal(["a","a!","a=","a?"],My.private_instance_methods.grep_sort_to_s(METHOD_REGEXP),'private methods before block')
+    assert_equal(["b","b!","b=","b?"],My.protected_instance_methods.grep_sort_to_s(METHOD_REGEXP),'protected methods before block')
+    assert_equal(["c","c!","c=","c?"],My.public_instance_methods.grep_sort_to_s(METHOD_REGEXP),'public methods before block')
+
+  end
+
+  protected
+
+end
+
+
+class Array
+  def grep_sort_to_s(regexp)
+    grep(regexp).sort.map{|x| x.to_s}
+  end
+end
+
+
+class My
+
+  private
+
+  def a
+  end
+
+  def a!
+  end
+
+  def a=
+  end
+
+  def a?
+  end
+
+  protected
+
+  def b
+  end
+
+  def b!
+  end
+
+  def b=
+  end
+
+  def b?
+  end
+
+  public
+
+  def c
+  end
+
+  def c!
+  end
+
+  def c=
+  end
+
+  def c?
+  end
+
+end

data/test/sixarm_ruby_ramp_test/csv_test.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+
+class CSVTest < Minitest::Test
+
+  def test_http_headers
+    h=CSV.http_headers
+    assert_equal('text/csv',h["Content-Type"])
+    assert_equal("attachment; filename=\"data.csv\"",h["Content-Disposition"])
+  end
+
+  def test_http_headers_with_filename
+    h=CSV.http_headers(:filename=>'foo')
+    assert_equal('text/csv',h["Content-Type"])
+    assert_equal("attachment; filename=\"foo\"",h["Content-Disposition"])
+  end
+
+ def test_http_headers_adjust_for_broken_msie_with_request_as_firefox
+   headers = {:request => MockRequest.new('HTTP_USER_AGENT' => 'firefox')}
+   headers = CSV.http_headers_adjust_for_broken_msie(headers)
+   assert_equal(nil,headers[:content_type])
+   assert_equal(nil,headers[:cache])
+ end
+
+ def test_http_headers_adjust_for_broken_msie_with_request_as_msie
+   headers = {:request => MockRequest.new('HTTP_USER_AGENT' => 'msie')}
+   headers = CSV.http_headers_adjust_for_broken_msie(headers)
+   assert_equal('text/plain',headers[:content_type])
+   assert_equal(false,headers[:cache])
+ end
+
+end
+
+class MockRequest
+
+  def initialize(env)
+    @env=env
+  end
+
+  def env
+    @env
+  end
+       
+end
+ 

data/test/sixarm_ruby_ramp_test/date_test.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+
+
+class DateTest < Minitest::Test
+
+
+  def test_weekday
+    # Start on Monday, January 1, 2007
+    assert( Date.new(2007,1,1).weekday?) 
+    assert( Date.new(2007,1,2).weekday?)
+    assert( Date.new(2007,1,3).weekday?)
+    assert( Date.new(2007,1,4).weekday?)
+    assert( Date.new(2007,1,5).weekday?)
+    assert(!Date.new(2007,1,6).weekday?)
+    assert(!Date.new(2007,1,7).weekday?)
+    assert( Date.new(2007,1,8).weekday?)
+  end
+
+
+  def test_weekend
+    # Start on Monday, January 1, 2007
+    assert(!Date.new(2007,1,1).weekend?) 
+    assert(!Date.new(2007,1,2).weekend?) 
+    assert(!Date.new(2007,1,3).weekend?) 
+    assert(!Date.new(2007,1,4).weekend?) 
+    assert(!Date.new(2007,1,5).weekend?) 
+    assert( Date.new(2007,1,6).weekend?) 
+    assert( Date.new(2007,1,7).weekend?) 
+    assert(!Date.new(2007,1,8).weekend?) 
+  end
+
+
+  def test_to_sql_with_non_zero_month_and_mday
+    assert_equal('2007-12-31',Date.new(2007,12,31).to_sql)
+  end
+
+
+  def test_to_sql_with_zero_month_and_mday
+    assert_equal('2007-01-02',Date.new(2007,1,2).to_sql)
+  end
+
+
+  def test_between
+    d1= Date.parse('2008-01-01')                                                                                  
+    d2= Date.parse('2009-01-01')                                                                                  
+    d3= Date.between(d1,d2)
+    assert(d3>=d1)
+    assert(d3<=d2)
+  end
+
+
+  def self.between(min,max)
+    min+rand(max-min)
+  end
+
+
+end
+

data/test/sixarm_ruby_ramp_test/enumerable_test.rb

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp'
+require 'set'
+
+
+class EnumerableTest < Minitest::Test
+
+  ITEMS = ['a','b','c']
+  MAPTEST = [123,"456"] # to test typecasts-- one is numeric and one is string
+  RGB = ["red","green","blue"]  # to test case changes
+
+
+  ########################################################################
+  #
+  #  typecast
+  #
+  ########################################################################
+
+
+  def test_to_h_with_unique_keys
+    a=[[:a,:b],[:c,:d],[:e,:f]] 
+    assert_equal({:a=>:b, :c=>:d, :e=>:f}, a.to_h)
+  end
+
+  def test_to_h_with_duplicate_keys
+    a=[[:a,:b],[:a,:c],[:a,:d]] 
+    assert_equal({:a=>[:b, :c, :d]}, a.to_h)
+  end
+
+  def test_index_by
+    assert_equal({3=>"red",4=>"blue",5=>"green"},RGB.index_by{|x| x.size})
+  end
+
+  def test_hash_by
+    assert_equal({3=>"RED",4=>"BLUE",5=>"GREEN"},RGB.hash_by{|x| [x.size,x.upcase]})
+  end
+
+    
+  ########################################################################
+  #
+  #  map
+  #
+  ########################################################################
+
+
+  class Mock #:nodoc: all
+    attr_accessor :id
+
+    def initialize(id)
+      @id=id
+    end
+
+    def to_a
+     [self]
+    end
+
+  end
+
+
+  A = Mock.new('a') 
+  B = Mock.new('b') 
+  C = Mock.new('c') 
+
+  
+  def test_map_id
+    assert_equal(['a','b','c'],[A,B,C].map_id)
+  end
+
+  def test_map_to_a
+    assert_equal([[123],["456"]],MAPTEST.to_set.map_to_a)
+  end
+
+  def test_map_to_f
+    assert_equal([123.0,456.0],MAPTEST.map_to_f)
+  end
+
+  def test_map_to_i
+    assert_equal([123,456],MAPTEST.map_to_i)
+  end
+
+  def test_map_to_s
+    assert_equal(["123","456"],MAPTEST.map_to_s)
+  end
+
+  def test_map_to_sym
+    assert_equal([:a,:b,:c],ITEMS.map_to_sym)
+  end
+
+  def test_map_with_index
+    assert_equal(['a0','b1','c2'],ITEMS.map_with_index{|x,i| "#{x}#{i}"})
+  end
+
+
+  ########################################################################
+  #
+  #  select
+  #
+  ########################################################################
+
+
+  def test_select_while
+    assert_equal([           ],ITEMS.select_while{|x| x < 'a' },'< a')
+    assert_equal(['a'        ],ITEMS.select_while{|x| x < 'b' },'< b')
+    assert_equal(['a','b'    ],ITEMS.select_while{|x| x < 'c' },'< c')
+    assert_equal(['a','b','c'],ITEMS.select_while{|x| x < 'd' },'< d')
+    assert_equal(['a','b','c'],ITEMS.select_while{|x| x < 'e' },'< e')
+  end
+
+
+  def test_select_until_condition
+    assert_equal([           ],ITEMS.select_until{|x| x == 'a' },'a')
+    assert_equal(['a'        ],ITEMS.select_until{|x| x == 'b' },'b')
+    assert_equal(['a','b'    ],ITEMS.select_until{|x| x == 'c' },'c')
+    assert_equal(['a','b','c'],ITEMS.select_until{|x| x == 'd' },'d')
+    assert_equal(['a','b','c'],ITEMS.select_until{|x| x == 'e' },'e')
+  end
+
+
+  def test_select_with_index
+    assert_equal([           ],ITEMS.select_with_index{|x,i| i < 0 },'i < 0')
+    assert_equal(['a'        ],ITEMS.select_with_index{|x,i| i < 1 },'i < 1')
+    assert_equal(['a','b'    ],ITEMS.select_with_index{|x,i| i < 2 },'i < 2')
+    assert_equal(['a','b','c'],ITEMS.select_with_index{|x,i| i < 3 },'i < 3')
+    assert_equal(['a','b','c'],ITEMS.select_with_index{|x,i| i < 4 },'i < 4')
+  end
+
+
+  ########################################################################
+  #
+  #  bisect
+  #
+  ########################################################################
+
+  def test_bisect
+    assert_equal([[           ],['a','b','c']],ITEMS.bisect{|x| x < 'a' },'< a')
+    assert_equal([['a'        ],[    'b','c']],ITEMS.bisect{|x| x < 'b' },'< b')
+    assert_equal([['a','b'    ],[        'c']],ITEMS.bisect{|x| x < 'c' },'< c')
+    assert_equal([['a','b','c'],[           ]],ITEMS.bisect{|x| x < 'd' },'< d')
+  end
+
+
+  ########################################################################
+  #
+  #  mutex?
+  #
+  ########################################################################
+
+  def test_mutex
+    assert_equal(true,  ITEMS.mutex?{|x| x < 'a'})
+    assert_equal(true,  ITEMS.mutex?{|x| x < 'b'})
+    assert_equal(false, ITEMS.mutex?{|x| x < 'c'})
+    assert_equal(false, ITEMS.mutex?{|x| x < 'd'})
+  end
+
+
+  ########################################################################
+  #
+  #  nitems
+  #
+  ########################################################################
+
+  def test_nitems?
+    assert_equal(true,  ITEMS.nitems?(0){|x| x < 'a'})
+    assert_equal(false, ITEMS.nitems?(1){|x| x < 'a'})
+    assert_equal(false, ITEMS.nitems?(2){|x| x < 'a'})
+    assert_equal(false, ITEMS.nitems?(0){|x| x < 'b'})
+    assert_equal(true,  ITEMS.nitems?(1){|x| x < 'b'})
+    assert_equal(false, ITEMS.nitems?(2){|x| x < 'b'})
+    assert_equal(false, ITEMS.nitems?(0){|x| x < 'c'})
+    assert_equal(false, ITEMS.nitems?(1){|x| x < 'c'})
+    assert_equal(true,  ITEMS.nitems?(2){|x| x < 'c'})
+  end
+
+
+  def test_nitems_while  
+    assert_equal(0,ITEMS.nitems_while{|x| x < 'a' },'< a')
+    assert_equal(1,ITEMS.nitems_while{|x| x < 'b' },'< b')
+    assert_equal(2,ITEMS.nitems_while{|x| x < 'c' },'< c')
+    assert_equal(3,ITEMS.nitems_while{|x| x < 'd' },'< d')
+    assert_equal(3,ITEMS.nitems_while{|x| x < 'e' },'< e')
+  end
+
+
+  def test_nitems_until
+    assert_equal(0,ITEMS.nitems_until{|x| x == 'a' },'a')
+    assert_equal(1,ITEMS.nitems_until{|x| x == 'b' },'b')
+    assert_equal(2,ITEMS.nitems_until{|x| x == 'c' },'c')
+    assert_equal(3,ITEMS.nitems_until{|x| x == 'd' },'d')
+    assert_equal(3,ITEMS.nitems_until{|x| x == 'e' },'e')
+  end
+
+  
+  def test_nitems_with_index
+    assert_equal(0,ITEMS.nitems_with_index{|x,i| i < 0 },'i < 0')
+    assert_equal(1,ITEMS.nitems_with_index{|x,i| i < 1 },'i < 1')
+    assert_equal(2,ITEMS.nitems_with_index{|x,i| i < 2 },'i < 2')
+    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 3 },'i < 3')
+    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 4 },'i < 4')
+  end
+
+
+  ########################################################################
+  #
+  #  strings
+  #
+  ########################################################################
+
+
+  def test_join_0
+    a='a'..'c'
+    assert_equal("abc",a.join,"join()")
+  end
+
+  def test_join_1
+    a='a'..'c'
+    assert_equal("a+b+c",a.join('+'),"join('+')")
+  end
+
+  def test_join_2
+    a='a'..'c'
+    assert_equal("+a-+b-+c-",a.join("+","-"),"join('+','-')")
+  end
+
+
+  ########################################################################
+  #
+  #  set math
+  #
+  ########################################################################
+
+  def test_intersect_true
+    assert_equal(true,['a','b'].intersect?(['b','c']))
+  end
+
+  def test_intersect_true_with_same
+    assert_equal(true,['a','b'].intersect?(['a','b']))
+  end
+
+  def test_intersect_false
+    assert_equal(false,['a','b'].intersect?(['c','d']))
+  end
+
+  def test_intersect_false_with_none
+    assert_equal(false,['a','b','c'].intersect?([]))
+  end
+
+  CARTESIAN_PRODUCT_EXPECT=[["a", "d", "g"],
+                            ["a", "d", "h"],
+                            ["a", "d", "i"],
+                            ["a", "e", "g"],
+                            ["a", "e", "h"],
+                            ["a", "e", "i"],
+                            ["a", "f", "g"],
+                            ["a", "f", "h"],
+                            ["a", "f", "i"],
+                            ["b", "d", "g"],
+                            ["b", "d", "h"],
+                            ["b", "d", "i"],
+                            ["b", "e", "g"],
+                            ["b", "e", "h"],
+                            ["b", "e", "i"],
+                            ["b", "f", "g"],
+                            ["b", "f", "h"],
+                            ["b", "f", "i"],
+                            ["c", "d", "g"],
+                            ["c", "d", "h"],
+                            ["c", "d", "i"],
+                            ["c", "e", "g"],
+                            ["c", "e", "h"],
+                            ["c", "e", "i"],
+                            ["c", "f", "g"],
+                            ["c", "f", "h"],
+                            ["c", "f", "i"]]
+
+  def test_cartesian_product_class_method
+    a1=['a','b','c']
+    a2=['d','e','f']
+    a3=['g','h','i']
+    actual=Enumerable.cartesian_product(a1,a2,a3)
+    assert_equal(CARTESIAN_PRODUCT_EXPECT,actual,'class method')
+  end
+
+  def test_cartesian_product_instance_method
+    a1=['a','b','c']
+    a2=['d','e','f']
+    a3=['g','h','i']
+    actual=a1.cartesian_product(a2,a3)
+    assert_equal(CARTESIAN_PRODUCT_EXPECT,actual,'instance method')
+  end
+
+  def test_power_set
+    a=['a','b','c']
+    expect=[[],['a'],['a','b'],['a','b','c'],['a','c'],['b'],['b','c'],['c']]
+    actual=a.power_set.sort
+    assert_equal(expect,actual)
+  end
+
+end
+
+
+
+